/*

 * L4_MABX.c

 *

 * Code generation for model "L4_MABX".

 *

 * Model version              : 1.898

 * Simulink Coder version : 8.14 (R2018a) 06-Feb-2018

 * C source code generated on : Thu Feb 27 17:58:03 2020

 *

 * Target selection: rti1401.tlc

 * Note: GRT includes extra infrastructure and instrumentation for prototyping

 * Embedded hardware selection: Custom Processor->Custom

 * Code generation objectives: Unspecified

 * Validation result: Not run

 */



#include "L4_MABX_trc_ptr.h"

#include "L4_MABX.h"

#include "L4_MABX_private.h"



/* Named constants for Chart: '<S79>/Chart' */

#define L4_MABX_IN_Init                ((uint8_T)1U)

#define L4_MABX_IN_NO_ACTIVE_CHILD     ((uint8_T)0U)

#define L4_MABX_IN_OperatorDisabled    ((uint8_T)2U)

#define L4_MABX_IN_OperatorEnabled     ((uint8_T)3U)



/* Named constants for Chart: '<S211>/Relay_control_state_machine' */

#define L4_MABX_IN_IGN_RELAY_LATCH     ((uint8_T)1U)

#define L4_MABX_IN_IGN_RELAY_UNLATCH   ((uint8_T)1U)

#define L4_MABX_IN_INITIAL             ((uint8_T)1U)

#define L4_MABX_IN_INV_RELAY_LATCH     ((uint8_T)2U)

#define L4_MABX_IN_INV_RELAY_UNLATCH   ((uint8_T)2U)

#define L4_MABX_IN_MABX_RELAY_LATCH    ((uint8_T)3U)

#define L4_MABX_IN_MABX_RELAY_UNLATCH  ((uint8_T)3U)

#define L4_MABX_IN_POWER_DOWN_ROUTINE  ((uint8_T)2U)

#define L4_MABX_IN_POWER_UP_ROUTINE    ((uint8_T)3U)

#define L4_MABX_IN_SENSOR_RELAY_LATCH  ((uint8_T)4U)

#define L4_MABX_IN_SENSOR_RELAY_UNLATCH ((uint8_T)4U)

#define L4_MABX_IN_WAIT                ((uint8_T)5U)



/* Named constants for Chart: '<S283>/Chart' */

#define L4_MABX_IN_OneLane             ((uint8_T)1U)

#define L4_MABX_IN_OneLane1            ((uint8_T)2U)

#define L4_MABX_IN_TwoLanes            ((uint8_T)3U)

#define L4_MABX_IN_TwoLanes1           ((uint8_T)4U)

#define L4_MABX_IN_ZeroLanes           ((uint8_T)5U)

#define L4_MABX_IN_ZeroLanes1          ((uint8_T)6U)

#define L4_MABX_IN_init_a              ((uint8_T)7U)



/* Named constants for Chart: '<S769>/Health State Machine PWM Sensor 1' */

#define L4_MABX_IN_ERROR               ((uint8_T)1U)

#define L4_MABX_IN_FAILURE_DETECTED    ((uint8_T)1U)

#define L4_MABX_IN_NO_FAILURE          ((uint8_T)2U)

#define L4_MABX_IN_PENDING             ((uint8_T)2U)



/* Named constants for Chart: '<S851>/Chart' */

#define L4_MABX_IN_DiagPassed          ((uint8_T)1U)

#define L4_MABX_IN_SwitchOff           ((uint8_T)2U)

#define L4_MABX_IN_SwitchOn            ((uint8_T)3U)

#define L4_MABX_IN_init_p              ((uint8_T)4U)



/* Named constants for Chart: '<S865>/Chart' */

#define L4_MABX_IN_CheckPacketCount    ((uint8_T)1U)

#define L4_MABX_IN_Init_l              ((uint8_T)2U)

#define L4_MABX_IN_InterframeDelay     ((uint8_T)3U)

#define L4_MABX_IN_InterframeDelay1    ((uint8_T)4U)

#define L4_MABX_IN_SendTPCM            ((uint8_T)5U)

#define L4_MABX_IN_SendTPDT            ((uint8_T)6U)

#define L4_MABX_IN_StartMsg            ((uint8_T)7U)

#define L4_MABX_IN_WaitForNextPeriod   ((uint8_T)8U)



/* Exported block signals */

real_T GLB_Absolute_Timestamp;         /* '<S423>/Rate Transition' */

real_T ReAX_ActualHandwheelPos;        /* '<S449>/Switch' */

real_T EthernetLinkStatus;             /* '<S405>/dsa_tcpip_setup' */

real_T CurrentAzimuth_rad;             /* '<S403>/Switch' */

real_T TargetAzimuth_rad;              /* '<S403>/Switch1' */

real_T TargetVelocity_kph;             /* '<S403>/Switch3' */

real_T Curvature;                      /* '<S403>/Switch4' */

real_T CrosstrackError;                /* '<S403>/Switch5' */

real_T CurrentVelocity_kph;            /* '<S403>/Switch2' */

real_T GPS_X;                          /* '<S403>/Switch6' */

real_T GPS_Y;                          /* '<S403>/Switch7' */

real_T GPS_Time;                       /* '<S403>/Switch8' */

real_T ReAX_EchoedSteerWheelPos;       /* '<S449>/Switch' */

real_T SteerWheelAngle;                /* '<S651>/S-Function1' */

real_T YawRate;                        /* '<S651>/S-Function1' */

real_T SPN1810_LongitudinalAcceleration;/* '<S651>/S-Function1' */

real_T WheelBasedVehicleSpeed;         /* '<S512>/S-Function1' */

real_T BrakeSwitch;                    /* '<S512>/S-Function1' */

real_T Lateral_Control_Rate_Limit;     /* '<S316>/Constant' */

real_T Lateral_Control_Output;         /* '<S281>/Sum1' */

real_T Lateral_Control_Rate_Limiter_Output;/* '<S316>/If_Then_Else' */

real_T Stanley_Rate_Limit;             /* '<S301>/Multiport Switch2' */

real_T Stanley_Set_Gain;               /* '<S280>/Multiport Switch1' */

real_T Understeer_Correction_Output;   /* '<S280>/Multiport Switch2' */

real_T Stanley_Output;                 /* '<S280>/Sum1' */

real_T Stanley_Rate_Limiter_Output;    /* '<S301>/If_Then_Else' */

real_T SteerCommandDeg;                /* '<S80>/sign flip' */

real_T DesiredSteeringAngle;           /* '<S80>/sign2' */

real_T Lateral_Control_Heading_Error;  /* '<S281>/Error Calc' */

uint32_T DIAG_CAN1_Count_Stuff_Errors; /* '<S28>/S-Function1' */

uint32_T DIAG_CAN1_Count_Format_Errors;/* '<S28>/S-Function1' */

uint32_T DIAG_CAN1_Count_Ack_Errors;   /* '<S28>/S-Function1' */

uint32_T DIAG_CAN1_Count_Bit0_Errors;  /* '<S28>/S-Function1' */

uint32_T DIAG_CAN1_Count_Bit1_Errors;  /* '<S28>/S-Function1' */

uint32_T DIAG_CAN1_Count_CRC_Errors;   /* '<S28>/S-Function1' */

uint32_T DIAG_CAN1_Count_RX_Lost;      /* '<S28>/S-Function1' */

uint32_T DIAG_CAN1_Count_RX_OK;        /* '<S28>/S-Function1' */

uint32_T DIAG_CAN1_Count_TX_OK;        /* '<S28>/S-Function1' */

uint32_T DIAG_CAN5_Count_Stuff_Errors; /* '<S20>/S-Function1' */

uint32_T DIAG_CAN5_Count_Format_Errors;/* '<S20>/S-Function1' */

uint32_T DIAG_CAN5_Count_Ack_Errors;   /* '<S20>/S-Function1' */

uint32_T DIAG_CAN5_Count_Bit0_Errors;  /* '<S20>/S-Function1' */

uint32_T DIAG_CAN5_Count_Bit1_Errors;  /* '<S20>/S-Function1' */

uint32_T DIAG_CAN5_Count_CRC_Errors;   /* '<S20>/S-Function1' */

uint32_T DIAG_CAN5_Count_RX_Lost;      /* '<S20>/S-Function1' */

uint32_T DIAG_CAN5_Count_RX_OK;        /* '<S20>/S-Function1' */

uint32_T DIAG_CAN5_Count_TX_OK;        /* '<S20>/S-Function1' */

uint32_T DIAG_CAN6_Count_Stuff_Errors; /* '<S21>/S-Function1' */

uint32_T DIAG_CAN6_Count_Format_Errors;/* '<S21>/S-Function1' */

uint32_T DIAG_CAN6_Count_Ack_Errors;   /* '<S21>/S-Function1' */

uint32_T DIAG_CAN6_Count_Bit0_Errors;  /* '<S21>/S-Function1' */

uint32_T DIAG_CAN6_Count_Bit1_Errors;  /* '<S21>/S-Function1' */

uint32_T DIAG_CAN6_Count_CRC_Errors;   /* '<S21>/S-Function1' */

uint32_T DIAG_CAN6_Count_RX_Lost;      /* '<S21>/S-Function1' */

uint32_T DIAG_CAN6_Count_RX_OK;        /* '<S21>/S-Function1' */

uint32_T DIAG_CAN6_Count_TX_OK;        /* '<S21>/S-Function1' */

uint32_T DIAG_CAN3_Count_Stuff_Errors; /* '<S18>/S-Function1' */

uint32_T DIAG_CAN3_Count_Format_Errors;/* '<S18>/S-Function1' */

uint32_T DIAG_CAN3_Count_Ack_Errors;   /* '<S18>/S-Function1' */

uint32_T DIAG_CAN3_Count_Bit0_Errors;  /* '<S18>/S-Function1' */

uint32_T DIAG_CAN3_Count_Bit1_Errors;  /* '<S18>/S-Function1' */

uint32_T DIAG_CAN3_Count_CRC_Errors;   /* '<S18>/S-Function1' */

uint32_T DIAG_CAN3_Count_RX_Lost;      /* '<S18>/S-Function1' */

uint32_T DIAG_CAN3_Count_RX_OK;        /* '<S18>/S-Function1' */

uint32_T DIAG_CAN3_Count_TX_OK;        /* '<S18>/S-Function1' */

uint32_T DIAG_CAN4_Count_Stuff_Errors; /* '<S19>/S-Function1' */

uint32_T DIAG_CAN4_Count_Format_Errors;/* '<S19>/S-Function1' */

uint32_T DIAG_CAN4_Count_Ack_Errors;   /* '<S19>/S-Function1' */

uint32_T DIAG_CAN4_Count_Bit0_Errors;  /* '<S19>/S-Function1' */

uint32_T DIAG_CAN4_Count_Bit1_Errors;  /* '<S19>/S-Function1' */

uint32_T DIAG_CAN4_Count_CRC_Errors;   /* '<S19>/S-Function1' */

uint32_T DIAG_CAN4_Count_RX_Lost;      /* '<S19>/S-Function1' */

uint32_T DIAG_CAN4_Count_RX_OK;        /* '<S19>/S-Function1' */

uint32_T DIAG_CAN4_Count_TX_OK;        /* '<S19>/S-Function1' */

uint32_T DIAG_CAN2_Count_Stuff_Errors; /* '<S17>/S-Function1' */

uint32_T DIAG_CAN2_Count_Format_Errors;/* '<S17>/S-Function1' */

uint32_T DIAG_CAN2_Count_Ack_Errors;   /* '<S17>/S-Function1' */

uint32_T DIAG_CAN2_Count_Bit0_Errors;  /* '<S17>/S-Function1' */

uint32_T DIAG_CAN2_Count_Bit1_Errors;  /* '<S17>/S-Function1' */

uint32_T DIAG_CAN2_Count_CRC_Errors;   /* '<S17>/S-Function1' */

uint32_T DIAG_CAN2_Count_RX_Lost;      /* '<S17>/S-Function1' */

uint32_T DIAG_CAN2_Count_RX_OK;        /* '<S17>/S-Function1' */

uint32_T DIAG_CAN2_Count_TX_OK;        /* '<S17>/S-Function1' */

real32_T REAX_Handwheel_Torque;        /* '<S425>/Data Type Conversion3' */

real32_T REAX_Handwheel_Velocity;      /* '<S425>/Data Type Conversion4' */

real32_T REAX_Pull_Compensation;       /* '<S425>/Data Type Conversion5' */

ENUM_CAN_STATUS_DIAG_T DIAG_CAN1_Status;/* '<S1>/Data Type Conversion' */

ENUM_CAN_STATUS_DIAG_T DIAG_CAN5_Status;/* '<S1>/Data Type Conversion5' */

ENUM_CAN_STATUS_DIAG_T DIAG_CAN6_Status;/* '<S1>/Data Type Conversion4' */

ENUM_CAN_STATUS_DIAG_T DIAG_CAN3_Status;/* '<S1>/Data Type Conversion3' */

ENUM_CAN_STATUS_DIAG_T DIAG_CAN4_Status;/* '<S1>/Data Type Conversion2' */

ENUM_CAN_STATUS_DIAG_T DIAG_CAN2_Status;/* '<S1>/Data Type Conversion1' */

uint8_T SupervisorMode;                /* '<S403>/Switch9' */

uint8_T REAX_Current_Mode;             /* '<S425>/Data Type Conversion' */

uint8_T REAX_Req_Mode;                 /* '<S425>/Data Type Conversion1' */

uint8_T REAX_Status;                   /* '<S425>/Data Type Conversion2' */

uint8_T GLB_SWVERSION_CPV_[100];       /* '<S1096>/Constant' */

uint8_T MABX_Mode;                     /* '<S76>/Switch' */

boolean_T EStop;                       /* '<S422>/Logical Operator1' */

boolean_T EnableSw;                    /* '<S751>/Switch' */

boolean_T EngagePB;                    /* '<S749>/AND2' */

boolean_T BrakeSW;                     /* '<S422>/Logical Operator3' */

boolean_T MABX_Heartbeat;              /* '<S404>/Cast To Boolean' */

boolean_T Heartbeat_Ok;                /* '<S409>/Switch1' */

boolean_T RTMapsOk;                    /* '<S403>/AND' */

boolean_T LogEventPB;                  /* '<S748>/AND2' */

boolean_T AutonomousOutputEnabled;     /* '<S76>/Autonomous Mode Switch' */

boolean_T Stanley_Limiter_Active;      /* '<S302>/Compare' */

boolean_T RateLimiterActive;           /* '<S325>/Compare' */

real_T Pedal_pwm_position;             /* '<S771>/Switch' */



/* Exported block parameters */

real_T APTC_PEDAL_LOW_IDLE_SW_THR_APV = 3.0;/* Variable: APTC_PEDAL_LOW_IDLE_SW_THR_APV

                                             * Referenced by: '<S75>/Constant'

                                             */

real_T APTC_TRQ_PED_INV_MAP_PED_POS_MPV[1328] = { 0.0, 0.3125, 0.859375, 1.15625,

  1.59375, 1.8125, 1.921875, 2.375, 3.8125, 4.3125, 4.84375, 4.96875, 5.71875,

  6.28125, 6.5625, 6.890625, 7.0, 7.8606557377049, 9.1229508196721,

  10.327868852459, 11.532786885246, 14.0, 15.25748502994, 15.425149700599,

  15.718562874251, 16.808383233533, 17.730538922156, 18.023952095808,

  18.275449101796, 18.904191616766, 19.449101796407, 19.658682634731,

  19.74251497006, 19.826347305389, 20.287425149701, 21.0, 21.516393442623,

  22.290983606557, 23.409836065574, 24.758196721311, 24.959016393443,

  25.217213114754, 26.22131147541, 26.995901639344, 27.311475409836,

  27.454918032787, 27.512295081967, 27.684426229508, 28.0, 32.101910828025,

  32.235668789809, 34.687898089172, 35.0, 36.734104046243, 38.815028901734,

  42.28323699422, 42.514450867052, 44.364161849711, 51.878612716763, 55.0,

  72.260273972603, 79.041095890411, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0,

  100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0,

  100.0, 100.0, 100.0, 100.0, 0.0, 0.33333333333333, 0.91666666666667,

  1.2333333333333, 1.7, 1.9333333333333, 2.05, 2.5333333333333, 4.0666666666667,

  4.6, 5.1666666666667, 5.3, 6.1, 6.7, 7.0, 8.3738317757009, 8.8317757009346,

  9.8130841121495, 11.252336448598, 12.626168224299, 14.0, 15.559585492228,

  16.647668393782, 16.79274611399, 17.046632124352, 17.989637305699,

  18.787564766839, 19.041450777202, 19.259067357513, 19.80310880829,

  20.274611398964, 20.455958549223, 20.528497409326, 20.60103626943, 21.0,

  21.476, 21.98, 22.736, 23.828, 25.144, 25.34, 25.592, 26.572, 27.328, 27.636,

  27.776, 27.832, 28.0, 28.478260869565, 32.478260869565, 32.608695652174, 35.0,

  35.777777777778, 37.444444444444, 39.444444444444, 42.777777777778, 43.0,

  44.777777777778, 52.0, 55.0, 61.237623762376, 63.688118811881, 71.262376237624,

  75.160891089109, 78.613861386139, 96.769801980198, 97.660891089109,

  98.329207920792, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0,

  100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 0.0, 0.57377049180328,

  1.577868852459, 2.1229508196721, 2.9262295081967, 3.327868852459,

  3.5286885245902, 4.3606557377049, 7.0, 7.8549618320611, 8.763358778626,

  8.9770992366412, 10.259541984733, 11.221374045802, 11.702290076336,

  12.263358778626, 12.450381679389, 12.851145038168, 13.43893129771, 14.0,

  14.757731958763, 16.309278350515, 17.39175257732, 17.536082474227,

  17.788659793814, 18.726804123711, 19.520618556701, 19.773195876289,

  19.989690721649, 20.530927835052, 21.0, 21.132575757576, 21.185606060606,

  21.238636363636, 21.530303030303, 21.981060606061, 22.458333333333,

  23.174242424242, 24.208333333333, 25.454545454545, 25.640151515152,

  25.878787878788, 26.806818181818, 27.522727272727, 27.814393939394,

  27.94696969697, 28.0, 28.202898550725, 28.574879227053, 31.685990338164,

  31.787439613527, 33.647342995169, 33.884057971014, 34.391304347826, 35.0,

  36.704545454545, 36.818181818182, 37.727272727273, 41.420454545455,

  42.954545454545, 46.136363636364, 47.386363636364, 51.25, 53.238636363636,

  55.0, 64.249684741488, 64.703656998739, 65.044136191677, 65.895334174023,

  75.769230769231, 79.457755359395, 82.919293820933, 84.451450189155,

  93.417402269861, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0,

  0.0, 0.92105263157895, 2.5328947368421, 3.4078947368421, 4.6973684210526,

  5.3421052631579, 5.6644736842105, 7.0, 8.9339339339339, 9.6066066066066,

  10.321321321321, 10.489489489489, 11.498498498498, 12.255255255255,

  12.633633633634, 13.075075075075, 13.222222222222, 13.537537537538, 14.0,

  14.65625, 15.3125, 16.65625, 17.59375, 17.71875, 17.9375, 18.75, 19.4375,

  19.65625, 19.84375, 20.3125, 20.71875, 20.875, 20.9375, 21.0, 21.310483870968,

  21.790322580645, 22.298387096774, 23.060483870968, 24.161290322581,

  25.487903225806, 25.685483870968, 25.939516129032, 26.927419354839,

  27.689516129032, 28.0, 28.143442622951, 28.200819672131, 28.372950819672,

  28.688524590164, 31.327868852459, 31.41393442623, 32.991803278689,

  33.19262295082, 33.622950819672, 34.139344262295, 35.0, 35.082474226804,

  35.742268041237, 38.422680412371, 39.536082474227, 41.845360824742,

  42.752577319588, 45.556701030928, 47.0, 48.278350515464, 55.0, 55.39603960396,

  55.693069306931, 56.435643564356, 65.049504950495, 68.267326732673,

  71.287128712871, 72.623762376238, 80.445544554455, 86.188118811881,

  97.326732673267, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 0.0,

  1.2068965517241, 3.3189655172414, 4.4655172413793, 6.1551724137931, 7.0,

  7.1412103746398, 7.7262247838617, 9.5821325648415, 10.227665706052,

  10.913544668588, 11.07492795389, 12.043227665706, 12.769452449568,

  13.132564841499, 13.556195965418, 13.697406340058, 14.0, 14.599221789883,

  15.171206225681, 15.743190661479, 16.91439688716, 17.731517509728,

  17.84046692607, 18.031128404669, 18.739299610895, 19.338521400778,

  19.529182879377, 19.692607003891, 20.101167315175, 20.455252918288,

  20.591439688716, 20.645914396887, 20.700389105058, 21.0, 21.526548672566,

  22.08407079646, 22.920353982301, 24.128318584071, 25.58407079646,

  25.800884955752, 26.079646017699, 27.163716814159, 28.0, 28.282051282051,

  28.410256410256, 28.461538461538, 28.615384615385, 28.897435897436,

  31.25641025641, 31.333333333333, 32.74358974359, 32.923076923077,

  33.307692307692, 33.769230769231, 34.538461538462, 34.589743589744, 35.0,

  36.768707482993, 37.503401360544, 39.027210884354, 39.625850340136,

  41.47619047619, 42.428571428571, 43.272108843537, 47.707482993197,

  47.925170068027, 48.08843537415, 48.496598639456, 53.231292517007, 55.0,

  57.99672489083, 59.323144104803, 67.085152838428, 72.78384279476,

  83.837336244541, 86.490174672489, 91.550218340611, 99.312227074236, 100.0,

  100.0, 100.0, 100.0, 0.0, 1.8918918918919, 5.2027027027027, 7.0,

  7.5340599455041, 7.8010899182561, 7.9346049046322, 8.4877384196185,

  10.242506811989, 10.852861035422, 11.50136239782, 11.653950953678,

  12.569482288828, 13.256130790191, 13.599455040872, 14.0, 14.185606060606,

  14.583333333333, 15.166666666667, 15.723484848485, 16.280303030303,

  17.420454545455, 18.215909090909, 18.32196969697, 18.507575757576,

  19.19696969697, 19.780303030303, 19.965909090909, 20.125, 20.522727272727,

  20.867424242424, 21.0, 21.065420560748, 21.130841121495, 21.490654205607,

  22.046728971963, 22.635514018692, 23.518691588785, 24.794392523364,

  26.331775700935, 26.560747663551, 26.855140186916, 28.0, 28.665492957746,

  28.93661971831, 29.05985915493, 29.109154929577, 29.257042253521,

  29.528169014085, 31.795774647887, 31.869718309859, 33.225352112676,

  33.397887323944, 33.767605633803, 34.211267605634, 34.950704225352, 35.0,

  35.381406436234, 36.930870083433, 37.574493444577, 38.909415971395,

  39.433849821216, 41.054827175209, 41.88915375447, 42.628128724672,

  46.513706793802, 46.704410011919, 46.847437425507, 47.205005959476,

  51.352800953516, 52.902264600715, 54.356376638856, 55.0, 62.917594654788,

  68.730512249443, 80.005567928731, 82.711581291759, 87.873051224944,

  95.790645879733, 96.492204899777, 100.0, 100.0, 100.0, 0.0, 7.0,

  7.8448275862069, 8.3034482758621, 8.9793103448276, 9.3172413793103,

  9.4862068965517, 10.186206896552, 12.406896551724, 13.179310344828, 14.0,

  14.157303370787, 15.101123595506, 15.808988764045, 16.162921348315,

  16.575842696629, 16.713483146067, 17.008426966292, 17.441011235955,

  17.85393258427, 18.266853932584, 19.112359550562, 19.702247191011,

  19.780898876404, 19.918539325843, 20.429775280899, 20.862359550562, 21.0,

  21.192660550459, 21.674311926606, 22.091743119266, 22.252293577982,

  22.316513761468, 22.380733944954, 22.733944954128, 23.279816513761,

  23.857798165138, 24.724770642202, 25.977064220183, 27.48623853211,

  27.711009174312, 28.0, 28.910780669145, 29.613382899628, 29.899628252788,

  30.029739776952, 30.081784386617, 30.237918215613, 30.524163568773,

  32.918215613383, 32.996282527881, 34.42750929368, 34.609665427509, 35.0,

  35.417633410673, 36.113689095128, 36.160092807425, 36.5313225058,

  38.039443155452, 38.665893271462, 39.965197215777, 40.475638051044,

  42.053364269142, 42.865429234339, 43.584686774942, 47.366589327146,

  47.552204176334, 47.691415313225, 48.039443155452, 52.07656612529,

  53.584686774942, 55.0, 56.296691568837, 63.884738527215, 69.455709711846,

  80.261472785486, 82.854855923159, 87.801494130203, 95.389541088581,

  96.061899679829, 99.423692636073, 100.0, 100.0, 0.0, 7.0, 9.378640776699,

  10.669902912621, 12.572815533981, 13.52427184466, 14.0, 14.394941634241,

  15.647859922179, 16.083657587549, 16.546692607004, 16.655642023346,

  17.309338521401, 17.799610894942, 18.044747081712, 18.330739299611,

  18.426070038911, 18.630350194553, 18.929961089494, 19.215953307393,

  19.501945525292, 20.087548638132, 20.496108949416, 20.550583657588,

  20.645914396887, 21.0, 21.836956521739, 22.103260869565, 22.33152173913,

  22.902173913043, 23.396739130435, 23.586956521739, 23.663043478261,

  23.739130434783, 24.157608695652, 24.804347826087, 25.489130434783,

  26.516304347826, 28.0, 29.305555555556, 29.5, 29.75, 30.722222222222,

  31.472222222222, 31.777777777778, 31.916666666667, 31.972222222222,

  32.138888888889, 32.444444444444, 35.0, 35.073529411765, 36.421568627451,

  36.593137254902, 36.960784313725, 37.401960784314, 38.137254901961,

  38.186274509804, 38.578431372549, 40.171568627451, 40.833333333333,

  42.205882352941, 42.745098039216, 44.411764705882, 45.269607843137,

  46.029411764706, 50.024509803922, 50.220588235294, 50.367647058824,

  50.735294117647, 55.0, 57.720930232558, 60.274418604651, 61.404651162791,

  68.018604651163, 72.874418604651, 82.293023255814, 84.553488372093,

  88.86511627907, 95.479069767442, 96.06511627907, 98.995348837209,

  99.497674418605, 100.0, 0.0, 14.0, 14.419520547945, 14.647260273973,

  14.982876712329, 15.150684931507, 15.234589041096, 15.582191780822,

  16.684931506849, 17.068493150685, 17.47602739726, 17.571917808219,

  18.147260273973, 18.578767123288, 18.794520547945, 19.046232876712,

  19.130136986301, 19.309931506849, 19.573630136986, 19.825342465753,

  20.077054794521, 20.592465753425, 20.952054794521, 21.0, 21.324503311258,

  22.529801324503, 23.549668874172, 23.87417218543, 24.152317880795,

  24.847682119205, 25.450331125828, 25.682119205298, 25.774834437086,

  25.867549668874, 26.377483443709, 27.165562913907, 28.0, 28.913043478261,

  30.231884057971, 31.821256038647, 32.057971014493, 32.36231884058,

  33.545893719807, 34.458937198068, 34.830917874396, 35.0, 35.054200542005,

  35.216802168022, 35.514905149051, 38.008130081301, 38.089430894309,

  39.579945799458, 39.769647696477, 40.176151761518, 40.663956639566,

  41.476964769648, 41.531165311653, 41.964769647696, 43.726287262873,

  44.457994579946, 45.975609756098, 46.571815718157, 48.414634146341,

  49.363143631436, 50.20325203252, 54.620596205962, 54.837398373984, 55.0,

  55.583910034602, 62.357266435986, 64.887543252595, 67.262110726644,

  68.313148788927, 74.463667820069, 78.979238754325, 87.737889273356,

  89.839965397924, 93.849480968858, 100.0, 100.0, 100.0, 100.0, 100.0, 0.0, 14.0,

  14.708092485549, 15.092485549133, 15.658959537572, 15.942196531792,

  16.083815028902, 16.670520231214, 18.531791907514, 19.179190751445,

  19.867052023121, 20.028901734104, 21.0, 21.739002932551, 22.108504398827,

  22.539589442815, 22.683284457478, 22.991202346041, 23.442815249267,

  23.873900293255, 24.304985337243, 25.187683284457, 25.803519061584,

  25.885630498534, 26.029325513196, 26.563049853372, 27.014662756598,

  27.158357771261, 27.281524926686, 27.589442815249, 27.856304985337,

  27.958944281525, 28.0, 28.083333333333, 28.541666666667, 29.25, 30.0, 31.125,

  32.75, 34.708333333333, 35.0, 35.291734197731, 36.426256077796,

  37.301458670989, 37.658022690438, 37.820097244733, 37.884927066451,

  38.079416531605, 38.435980551053, 41.418152350081, 41.515397082658,

  43.298217179903, 43.525121555916, 44.011345218801, 44.594813614263,

  45.567260940032, 45.63209076175, 46.150729335494, 48.257698541329,

  49.132901134522, 50.948136142626, 51.661264181523, 53.865478119935, 55.0,

  56.15671641791, 62.238805970149, 62.537313432836, 62.761194029851,

  63.320895522388, 69.813432835821, 72.238805970149, 74.514925373134,

  75.522388059701, 81.417910447761, 85.746268656716, 94.141791044776,

  96.15671641791, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 0.0, 14.0,

  16.987804878049, 18.609756097561, 21.0, 21.175942549372, 21.263913824057,

  21.628366247756, 22.784560143627, 23.18671454219, 23.614003590664,

  23.714542190305, 24.317773788151, 24.770197486535, 24.996409335727,

  25.260323159785, 25.34829443447, 25.536804308797, 25.81328545781,

  26.077199281867, 26.341113105925, 26.881508078995, 27.258527827648,

  27.308797127469, 27.396768402154, 27.723518850987, 28.0, 28.39837398374,

  28.739837398374, 29.593495934959, 30.333333333333, 30.617886178862,

  30.731707317073, 30.845528455285, 31.471544715447, 32.439024390244,

  33.463414634146, 35.0, 36.553784860558, 38.426294820717, 38.705179282869,

  39.06374501992, 40.458167330677, 41.533864541833, 41.972111553785,

  42.171314741036, 42.250996015936, 42.490039840637, 42.92828685259,

  46.593625498008, 46.713147410359, 48.90438247012, 49.183266932271,

  49.780876494024, 50.498007968127, 51.693227091633, 51.772908366534,

  52.410358565737, 55.0, 55.966587112172, 57.971360381862, 58.758949880668,

  61.193317422434, 62.44630071599, 63.556085918854, 69.391408114558,

  69.677804295943, 69.892601431981, 70.429594272076, 76.658711217184,

  78.985680190931, 81.169451073986, 82.136038186158, 87.792362768496,

  91.945107398568, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 0.0,

  21.0, 21.414551607445, 21.639593908629, 21.971235194585, 22.137055837563,

  22.219966159052, 22.56345177665, 23.653130287648, 24.032148900169,

  24.434856175973, 24.529610829103, 25.098138747885, 25.524534686971,

  25.737732656514, 25.986463620981, 26.06937394247, 26.24703891709,

  26.507614213198, 26.756345177665, 27.005076142132, 27.514382402707,

  27.869712351946, 27.917089678511, 28.0, 30.394736842105, 32.421052631579,

  33.065789473684, 33.618421052632, 35.0, 35.668380462725, 35.925449871465,

  36.028277634961, 36.131105398458, 36.696658097686, 37.570694087404,

  38.496143958869, 39.884318766067, 41.889460154242, 44.305912596401,

  44.665809768638, 45.12853470437, 46.928020565553, 48.316195372751,

  48.881748071979, 49.13881748072, 49.241645244216, 49.550128534704,

  50.115681233933, 54.845758354756, 55.0, 57.201957295374, 57.482206405694,

  58.082740213523, 58.803380782918, 60.004448398577, 60.084519572954,

  60.725088967972, 63.327402135231, 64.408362989324, 66.650355871886,

  67.531138790036, 70.253558718861, 71.654804270463, 72.89590747331,

  79.421708185053, 79.741992882562, 79.982206405694, 80.582740213523,

  87.548932384342, 90.151245551601, 92.593416370107, 93.674377224199, 100.0,

  100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 0.0, 21.0,

  21.822147651007, 22.268456375839, 22.926174496644, 23.255033557047,

  23.419463087248, 24.10067114094, 26.261744966443, 27.013422818792,

  27.812080536913, 28.0, 29.191489361702, 30.085106382979, 30.531914893617,

  31.053191489362, 31.22695035461, 31.599290780142, 32.145390070922,

  32.666666666667, 33.187943262411, 34.255319148936, 35.0, 35.298507462687,

  35.820895522388, 37.761194029851, 39.402985074627, 39.925373134328,

  40.373134328358, 41.492537313433, 42.462686567164, 42.835820895522,

  42.985074626866, 43.134328358209, 43.955223880597, 45.223880597015,

  46.567164179104, 48.582089552239, 51.492537313433, 55.0, 55.381355932203,

  55.871670702179, 57.778450363196, 59.249394673123, 59.848668280872,

  60.121065375303, 60.230024213075, 60.556900726392, 61.15617433414,

  66.168280871671, 66.331719128329, 69.32808716707, 69.709443099274,

  70.526634382567, 71.507263922518, 73.141646489104, 73.250605326877,

  74.122276029056, 77.663438256659, 79.134382566586, 82.185230024213,

  83.383777239709, 87.088377723971, 88.995157384988, 90.68401937046,

  99.56416464891, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0,

  100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 0.0, 21.0, 28.0,

  28.383285302594, 28.948126801153, 29.230547550432, 29.371757925072,

  29.956772334294, 31.812680115274, 32.458213256484, 33.14409221902,

  33.305475504323, 34.273775216138, 35.0, 36.333333333333, 37.888888888889,

  38.407407407407, 39.518518518519, 41.148148148148, 42.703703703704,

  44.259259259259, 47.444444444444, 49.666666666667, 49.962962962963,

  50.481481481481, 52.407407407407, 54.037037037037, 54.555555555556, 55.0,

  55.941422594142, 56.757322175732, 57.071129707113, 57.196652719665,

  57.322175732218, 58.012552301255, 59.07949790795, 60.20920502092,

  61.903765690377, 64.351464435146, 67.301255230126, 67.740585774059,

  68.305439330544, 70.502092050209, 72.196652719665, 72.887029288703,

  73.200836820084, 73.326359832636, 73.702928870293, 74.393305439331,

  80.167364016736, 80.355648535565, 83.807531380753, 84.246861924686,

  85.188284518828, 86.317991631799, 88.200836820084, 88.326359832636,

  89.330543933054, 93.410041841004, 95.10460251046, 98.619246861925, 100.0,

  100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0,

  100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 0.0,

  28.0, 28.95703125, 29.4765625, 30.2421875, 30.625, 30.81640625, 31.609375,

  34.125, 35.0, 37.098765432099, 37.592592592593, 40.555555555556,

  42.777777777778, 43.888888888889, 45.185185185185, 45.617283950617,

  46.543209876543, 47.901234567901, 49.197530864198, 50.493827160494,

  53.148148148148, 55.0, 55.234680573664, 55.645371577575, 57.170795306389,

  58.461538461538, 58.87222946545, 59.224250325945, 60.104302477184,

  60.867014341591, 61.16036505867, 61.277705345502, 61.395045632334,

  62.040417209909, 63.037809647979, 64.093872229465, 65.677966101695,

  67.966101694915, 70.723598435463, 71.134289439374, 71.662320730117,

  73.715775749674, 75.299869621904, 75.945241199478, 76.238591916558,

  76.35593220339, 76.707953063885, 77.35332464146, 82.750977835724,

  82.926988265971, 86.153846153846, 86.564537157757, 87.444589308996,

  88.500651890482, 90.26075619296, 90.378096479791, 91.316818774446,

  95.13037809648, 96.714471968709, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0,

  100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0,

  100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0,

  100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0,

  100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0,

  100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0,

  100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0,

  100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0,

  100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0,

  100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0,

  100.0 } ;                            /* Variable: APTC_TRQ_PED_INV_MAP_PED_POS_MPV

                                        * Referenced by: '<S85>/2D_Lookup_Table'

                                        */



real_T APTC_TRQ_PED_INV_MAP_TRQ_STEPS[83] = { 0.0, 20.0, 55.0, 74.0, 102.0,

  116.0, 123.0, 152.0, 244.0, 276.0, 310.0, 318.0, 366.0, 402.0, 420.0, 441.0,

  448.0, 463.0, 485.0, 506.0, 527.0, 570.0, 600.0, 604.0, 611.0, 637.0, 659.0,

  666.0, 672.0, 687.0, 700.0, 705.0, 707.0, 709.0, 720.0, 737.0, 755.0, 782.0,

  821.0, 868.0, 875.0, 884.0, 919.0, 946.0, 957.0, 962.0, 964.0, 970.0, 981.0,

  1073.0, 1076.0, 1131.0, 1138.0, 1153.0, 1171.0, 1201.0, 1203.0, 1219.0, 1284.0,

  1311.0, 1367.0, 1389.0, 1457.0, 1492.0, 1523.0, 1686.0, 1694.0, 1700.0, 1715.0,

  1889.0, 1954.0, 2015.0, 2042.0, 2200.0, 2316.0, 2541.0, 2595.0, 2698.0, 2856.0,

  2870.0, 2940.0, 2952.0, 2964.0 } ;   /* Variable: APTC_TRQ_PED_INV_MAP_TRQ_STEPS

                                        * Referenced by: '<S85>/2D_Lookup_Table'

                                        */



real_T APTC_TRQ_PED_TRQ_DATA_MPV[128] = { 0.0, 448.0, 570.0, 737.0, 981.0,

  1138.0, 1311.0, 1457.0, 0.0, 420.0, 527.0, 720.0, 970.0, 1131.0, 1311.0,

  1715.0, 0.0, 244.0, 506.0, 700.0, 964.0, 1171.0, 1523.0, 2316.0, 0.0, 152.0,

  485.0, 709.0, 957.0, 1201.0, 1686.0, 2595.0, 0.0, 116.0, 463.0, 720.0, 946.0,

  1219.0, 1954.0, 2870.0, 0.0, 74.0, 441.0, 705.0, 919.0, 1203.0, 2042.0, 2940.0,

  0.0, 20.0, 310.0, 666.0, 884.0, 1153.0, 2015.0, 2952.0, 0.0, 20.0, 123.0,

  637.0, 821.0, 1073.0, 1889.0, 2964.0, 0.0, 20.0, 20.0, 604.0, 755.0, 962.0,

  1700.0, 2856.0, 0.0, 20.0, 20.0, 366.0, 707.0, 875.0, 1492.0, 2698.0, 0.0,

  20.0, 20.0, 102.0, 659.0, 782.0, 1284.0, 2541.0, 0.0, 20.0, 20.0, 20.0, 611.0,

  687.0, 1076.0, 2200.0, 0.0, 20.0, 20.0, 20.0, 318.0, 600.0, 868.0, 1694.0, 0.0,

  20.0, 20.0, 20.0, 55.0, 402.0, 672.0, 1389.0, 0.0, 20.0, 20.0, 20.0, 20.0,

  276.0, 600.0, 1367.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 } ;/* Variable: APTC_TRQ_PED_TRQ_DATA_MPV

                                                                   * Referenced by: '<S83>/2-D Lookup Table'

                                                                   */



real_T APTC_TRQ_PED_TRQ_ESPD_STEP_MPV[16] = { 500.0, 650.0, 885.0, 950.0, 1050.0,

  1120.0, 1240.0, 1360.0, 1475.0, 1590.0, 1710.0, 1830.0, 1950.0, 2150.0, 2300.0,

  2350.0 } ;                           /* Variable: APTC_TRQ_PED_TRQ_ESPD_STEP_MPV

                                        * Referenced by:

                                        *   '<S83>/2-D Lookup Table'

                                        *   '<S85>/2D_Lookup_Table'

                                        */



real_T APTC_TRQ_PED_TRQ_POS_STEP_MPV[8] = { 0.0, 7.0, 14.0, 21.0, 28.0, 35.0,

  55.0, 100.0 } ;                      /* Variable: APTC_TRQ_PED_TRQ_POS_STEP_MPV

                                        * Referenced by: '<S83>/2-D Lookup Table'

                                        */



real_T BRK_DEM_KD_DATA_MPV[8] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 } ;/* Variable: BRK_DEM_KD_DATA_MPV

                                                                      * Referenced by: '<S149>/1D_Lookup_Table'

                                                                      */



real_T BRK_DEM_KI_DATA_MPV[8] = { -1.5, -1.5, -1.5, -1.5, -1.5, -1.5, -1.5, -1.5

} ;                                    /* Variable: BRK_DEM_KI_DATA_MPV

                                        * Referenced by: '<S148>/1D_Lookup_Table'

                                        */



real_T BRK_DEM_KP_DATA_MPV[8] = { -4.0, -4.0, -4.0, -4.0, -4.0, -4.0, -4.0, -4.0

} ;                                    /* Variable: BRK_DEM_KP_DATA_MPV

                                        * Referenced by: '<S147>/1D_Lookup_Table'

                                        */



real_T BRK_DEM_MASS_STEP_MPV[8] = { 0.0, 5000.0, 10000.0, 20000.0, 30000.0,

  40000.0, 50000.0, 54000.0 } ;        /* Variable: BRK_DEM_MASS_STEP_MPV

                                        * Referenced by:

                                        *   '<S147>/1D_Lookup_Table'

                                        *   '<S148>/1D_Lookup_Table'

                                        *   '<S149>/1D_Lookup_Table'

                                        */



real_T BRK_GOV_FF_DECEL_RATE_DATA_MPV[32] = { 0.0, -0.39, -1.76, -3.13, -4.5,

  -5.87, -7.24, -8.61, -9.98, -11.35, -12.72, -14.09, -15.46, -16.83, -18.2,

  -19.57, 0.0, -0.12, -0.53, -0.94, -1.35, -1.76, -2.17, -2.58, -2.99, -3.41,

  -3.82, -4.23, -4.64, -5.05, -5.46, -5.87 } ;/* Variable: BRK_GOV_FF_DECEL_RATE_DATA_MPV

                                               * Referenced by: '<S199>/2D_Lookup_Table'

                                               */



real_T BRK_GOV_FF_DECEL_RATE_STEP_MPV[16] = { -19.57, -18.2, -16.83, -15.46,

  -14.09, -12.72, -11.35, -9.98, -8.61, -7.24, -5.87, -4.5, -3.13, -1.76, -0.39,

  0.0 } ;                              /* Variable: BRK_GOV_FF_DECEL_RATE_STEP_MPV

                                        * Referenced by:

                                        *   '<S200>/2D_Lookup_Table'

                                        *   '<S201>/2D_Lookup_Table'

                                        */



real_T BRK_GOV_FF_MASS_STEP_MPV[2] = { 9035.0, 36287.0 } ;/* Variable: BRK_GOV_FF_MASS_STEP_MPV

                                                           * Referenced by:

                                                           *   '<S199>/2D_Lookup_Table'

                                                           *   '<S200>/2D_Lookup_Table'

                                                           *   '<S201>/2D_Lookup_Table'

                                                           */



real_T BRK_GOV_FF_PRESS_KPA_DATA_MPV[32] = { 1034.0, 965.0, 896.0, 827.0, 758.0,

  689.0, 621.0, 552.0, 483.0, 414.0, 345.0, 276.0, 207.0, 138.0, 69.0, 0.0,

  2585.0, 2413.0, 2240.0, 2068.0, 1895.0, 1723.0, 1553.0, 1380.0, 1208.0, 1035.0,

  863.0, 690.0, 518.0, 345.0, 173.0, 0.0 } ;/* Variable: BRK_GOV_FF_PRESS_KPA_DATA_MPV

                                             * Referenced by:

                                             *   '<S200>/2D_Lookup_Table'

                                             *   '<S201>/2D_Lookup_Table'

                                             */



real_T BRK_GOV_FF_PRESS_KPA_STEP_MPV[16] = { 0.0, 69.0, 138.0, 207.0, 276.0,

  345.0, 414.0, 483.0, 552.0, 621.0, 689.0, 758.0, 827.0, 896.0, 965.0, 1034.0 }

;                                      /* Variable: BRK_GOV_FF_PRESS_KPA_STEP_MPV

                                        * Referenced by: '<S199>/2D_Lookup_Table'

                                        */



real_T DISTANCE_M = 200.0;             /* Variable: DISTANCE_M

                                        * Referenced by: '<S81>/DISTANCE_M'

                                        */

real_T Lateral_Control_Curvature_Limit = 0.5;/* Variable: Lateral_Control_Curvature_Limit

                                              * Referenced by:

                                              *   '<S281>/Constant3'

                                              *   '<S281>/Constant5'

                                              */

real_T Lateral_Control_D = 0.07;       /* Variable: Lateral_Control_D

                                        * Referenced by: '<S313>/Derivative Gain'

                                        */

real_T Lateral_Control_Error_Limit = 0.1;/* Variable: Lateral_Control_Error_Limit

                                          * Referenced by:

                                          *   '<S280>/Error Saturation'

                                          *   '<S281>/Constant'

                                          *   '<S281>/Constant1'

                                          */

real_T Lateral_Control_Error_Rate_Limit = 0.04;/* Variable: Lateral_Control_Error_Rate_Limit

                                                * Referenced by:

                                                *   '<S281>/Constant10'

                                                *   '<S281>/Constant7'

                                                *   '<S281>/Constant8'

                                                *   '<S281>/Constant9'

                                                */

real_T Lateral_Control_I = 0.0;        /* Variable: Lateral_Control_I

                                        * Referenced by: '<S313>/Integral Gain'

                                        */

real_T Lateral_Control_P = 0.6;        /* Variable: Lateral_Control_P

                                        * Referenced by:

                                        *   '<S281>/PGain'

                                        *   '<S313>/Proportional Gain'

                                        */

real_T Lateral_Control_Pole = 0.98;    /* Variable: Lateral_Control_Pole

                                        * Referenced by: '<S317>/GainPole'

                                        */

real_T Lateral_Control_Rate_Limit_APV = 0.04;/* Variable: Lateral_Control_Rate_Limit_APV

                                              * Referenced by:

                                              *   '<S301>/Constant'

                                              *   '<S316>/Constant'

                                              */

real_T Lateral_Control_YawRate_Limit = 1.0;/* Variable: Lateral_Control_YawRate_Limit

                                            * Referenced by:

                                            *   '<S281>/Constant2'

                                            *   '<S281>/Constant4'

                                            */

real_T Lateral_Control_Zero = 0.99;    /* Variable: Lateral_Control_Zero

                                        * Referenced by: '<S317>/GainZero'

                                        */

real_T PROPB_REAX_1_E4_DESIRED_POSITION_APV = 0.0;/* Variable: PROPB_REAX_1_E4_DESIRED_POSITION_APV

                                                   * Referenced by: '<S1000>/Constant7'

                                                   */

real_T REAX_OFFSET_APV = 0.0;          /* Variable: REAX_OFFSET_APV

                                        * Referenced by:

                                        *   '<S80>/Constant'

                                        *   '<S280>/ReAX Offset'

                                        *   '<S281>/Constant6'

                                        */

real_T STANLEY_GAIN_APV = 0.55;        /* Variable: STANLEY_GAIN_APV

                                        * Referenced by: '<S280>/Stanley Gain K'

                                        */

real_T STANLEY_GAIN_KDSTEER_APV = 0.18;/* Variable: STANLEY_GAIN_KDSTEER_APV

                                        * Referenced by: '<S280>/Stanley Gain Kdsteer'

                                        */

real_T STANLEY_GAIN_KDYAW_APV = -0.35; /* Variable: STANLEY_GAIN_KDYAW_APV

                                        * Referenced by: '<S280>/Stanley Gain Kdyaw'

                                        */

real_T STANLEY_GAIN_KSOFT_APV = 0.0;   /* Variable: STANLEY_GAIN_KSOFT_APV

                                        * Referenced by: '<S280>/Stanley Gain Ksoft'

                                        */

real_T STEERCTRL_WHEEL_ANGLE_DATA_MPV[72] = { -800.02001953125, -780.02899169922,

  -760.03399658203, -740.0, -720.0, -700.00402832031, -680.0, -660.01397705078,

  -640.01898193359, -620.02398681641, -600.02001953125, -580.03399658203,

  -560.03900146484, -540.0, -520.00402832031, -500.00900268555, -480.01400756836,

  -460.01901245117, -440.02398681641, -420.01998901367, -400.03399658203,

  -380.03900146484, -360.0, -340.00399780273, -320.00900268555, -300.01400756836,

  -280.01901245117, -260.02398681641, -240.02900695801, -220.03399658203,

  -200.03900146484, -180.0, -160.00399780273, -140.00900268555, -120.01399993896,

  -100.01899719238, -80.024002075195, -60.028999328613, -40.034000396729,

  0.52700001001358, 29.969999313354, 50.00899887085, 69.959999084473,

  89.949996948242, 109.99500274658, 129.99000549316, 149.98500061035,

  170.0240020752, 189.97500610352, 209.9700012207, 229.96499633789,

  249.96000671387, 270.0, 289.99499511719, 309.98999023438, 329.98498535156,

  349.98001098633, 369.97500610352, 390.01400756836, 410.00900268555, 450.0,

  470.0299987793, 489.98999023438, 509.98498535156, 529.97998046875,

  549.97497558594, 569.96997070313, 589.96502685547, 610.21997070313, 630.0,

  650.25, 670.0 } ;                    /* Variable: STEERCTRL_WHEEL_ANGLE_DATA_MPV

                                        * Referenced by: '<S276>/1D_Lookup_Table'

                                        */



real_T STEERCTRL_WHEEL_ANGLE_STEP_MPV[72] = { -46.0, -44.5, -43.0, -42.0, -40.0,

  -39.0, -37.5, -36.5, -35.0, -34.0, -33.0, -31.5, -30.5, -29.0, -28.0, -26.5,

  -25.5, -24.5, -23.5, -22.0, -21.0, -20.0, -19.0, -17.5, -16.5, -15.5, -14.0,

  -13.0, -12.0, -11.0, -10.0, -8.5, -7.5, -6.5, -5.0, -4.0, -3.0, -2.0, -1.0,

  0.0, 1.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0,

  15.0, 16.0, 17.0, 18.5, 19.5, 20.5, 21.5, 23.5, 24.5, 25.5, 26.5, 27.5, 28.5,

  29.0, 30.0, 31.0, 31.5, 32.5, 33.0 } ;/* Variable: STEERCTRL_WHEEL_ANGLE_STEP_MPV

                                         * Referenced by: '<S276>/1D_Lookup_Table'

                                         */



real_T TQ_DEM_GEAR_RATIO_STEP_MPV[8] = { 0.0, 0.2, 4.0, 8.0, 10.0, 16.0, 18.0,

  20.0 } ;                             /* Variable: TQ_DEM_GEAR_RATIO_STEP_MPV

                                        * Referenced by:

                                        *   '<S241>/2D_Lookup_Table'

                                        *   '<S242>/2D_Lookup_Table'

                                        *   '<S243>/2D_Lookup_Table'

                                        */



real_T TQ_DEM_KD_DATA_MPV[64] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,

  0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,

  0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,

  0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,

  0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 } ;/* Variable: TQ_DEM_KD_DATA_MPV

                                        * Referenced by: '<S243>/2D_Lookup_Table'

                                        */



real_T TQ_DEM_KI_DATA_MPV[64] = { 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7,

  0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7,

  0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7,

  0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7,

  0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7 } ;/* Variable: TQ_DEM_KI_DATA_MPV

                                        * Referenced by: '<S242>/2D_Lookup_Table'

                                        */



real_T TQ_DEM_KP_DATA_MPV[64] = { 4.0, 5.0, 5.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0,

  5.0, 5.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 5.0, 5.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0,

  5.0, 5.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 5.0, 5.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0,

  5.0, 5.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 5.0, 5.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0,

  5.0, 5.0, 4.0, 4.0, 4.0, 4.0, 4.0 } ;/* Variable: TQ_DEM_KP_DATA_MPV

                                        * Referenced by: '<S241>/2D_Lookup_Table'

                                        */



real_T TQ_DEM_MASS_STEP_MPV[8] = { 0.0, 5000.0, 10000.0, 20000.0, 30000.0,

  40000.0, 50000.0, 54000.0 } ;        /* Variable: TQ_DEM_MASS_STEP_MPV

                                        * Referenced by:

                                        *   '<S241>/2D_Lookup_Table'

                                        *   '<S242>/2D_Lookup_Table'

                                        *   '<S243>/2D_Lookup_Table'

                                        */



real_T UndersteerCorection = 0.18;     /* Variable: UndersteerCorection

                                        * Referenced by:

                                        *   '<S280>/Understeer Corection'

                                        *   '<S281>/Understeer Corection'

                                        */

real_T VSPD_TARGET_KPH_APV = 0.0;      /* Variable: VSPD_TARGET_KPH_APV

                                        * Referenced by: '<S81>/VSPD_TARGET_KPH_APV'

                                        */

real_T YAW_RATE_OFFSET_APV = -0.0066;  /* Variable: YAW_RATE_OFFSET_APV

                                        * Referenced by:

                                        *   '<S280>/YAW_RATE_OFFSET_APV'

                                        *   '<S281>/YAW_RATE_OFFSET_APV'

                                        */

real_T Yaw_Rate_FF_Gain = 0.2;         /* Variable: Yaw_Rate_FF_Gain

                                        * Referenced by: '<S281>/RateFeedbackGain'

                                        */

ENUM_AUTONOMOUS_MODE_T AUTONOMOUS_MODE_SELECTOR_APV =

  ENUM_AUTONOMOUS_MODE_T_AUTO;         /* Variable: AUTONOMOUS_MODE_SELECTOR_APV

                                        * Referenced by: '<S76>/AUTONOMOUS_MODE_SELECTOR_APV'

                                        */

ENUM_CAN_RX_T CANR_PROPB_XPR_1_50_CHANNEL_APV = ENUM_CAN_RX_T_RX_CAN_3;/* Variable: CANR_PROPB_XPR_1_50_CHANNEL_APV

                                                                      * Referenced by: '<S452>/Constant'

                                                                      */

ENUM_CAN_RX_T PROPB_REAX_CHANNEL_APV = ENUM_CAN_RX_T_RX_CAN_2;/* Variable: PROPB_REAX_CHANNEL_APV

                                                               * Referenced by:

                                                               *   '<S450>/Constant'

                                                               *   '<S451>/Constant'

                                                               *   '<S472>/Constant3'

                                                               */

ENUM_LAT_STEER_SOURCE_T LAT_STEER_SRC_SELECTOR_APV =

  ENUM_LAT_STEER_SOURCE_T_PIC_STANLEY; /* Variable: LAT_STEER_SRC_SELECTOR_APV

                                        * Referenced by: '<S80>/LAT_STEER_SRC_SELECTOR_APV'

                                        */

ENUM_LONG_SPEED_DEMAND_SOURCE_T LONG_SPEED_SRC_SELECTOR_APV =

  ENUM_LONG_SPEED_DEMAND_SOURCE_T_WAYPOINTS;/* Variable: LONG_SPEED_SRC_SELECTOR_APV

                                             * Referenced by:

                                             *   '<S80>/LONG_SPEED_SRC_SELECTOR_APV'

                                             *   '<S81>/LONG_SPEED_SRC_SELECTOR_APV'

                                             */

ENUM_REAX_OPERATION_MODE_T PROPB_REAX_1_E4_DESIRED_OPMODE_APV =

  ENUM_REAX_OPERATION_MODE_T_POSITION_CTRL_MODE;/* Variable: PROPB_REAX_1_E4_DESIRED_OPMODE_APV

                                                 * Referenced by: '<S983>/Constant6'

                                                 */

ENUM_STEERING_POS_SIGNAL_SOURCE_T PROPB_REAX_1_E4_DES_POS_SIG_SRC_APV =

  ENUM_STEERING_POS_SIGNAL_SOURCE_T_ESTIMATION;/* Variable: PROPB_REAX_1_E4_DES_POS_SIG_SRC_APV

                                                * Referenced by: '<S1000>/Constant1'

                                                */

ENUM_SWITCH_T LATERAL_GAIN_SCHEDULE_APV = ENUM_SWITCH_T_ON;/* Variable: LATERAL_GAIN_SCHEDULE_APV

                                                            * Referenced by:

                                                            *   '<S280>/Use Gain Schedule'

                                                            *   '<S280>/Use Gain Schedule1'

                                                            *   '<S281>/Use Gain Schedule'

                                                            *   '<S301>/Use Gain Schedule'

                                                            */

ENUM_SWITCH_T RATE_LIMITER_ENABLE_APV = ENUM_SWITCH_T_ON;/* Variable: RATE_LIMITER_ENABLE_APV

                                                          * Referenced by:

                                                          *   '<S301>/RATE_LIMITER_ENABLE_APV'

                                                          *   '<S316>/RATE_LIMITER_ENABLE_APV'

                                                          */



/* Block signals (default storage) */

B_L4_MABX_T L4_MABX_B;



/* Block states (default storage) */

DW_L4_MABX_T L4_MABX_DW;



/* Previous zero-crossings (trigger) states */

PrevZCX_L4_MABX_T L4_MABX_PrevZCX;



/* Real-time model */

RT_MODEL_L4_MABX_T L4_MABX_M_;

RT_MODEL_L4_MABX_T *const L4_MABX_M = &L4_MABX_M_;



/* Forward declaration for local functions */

static int32_T safe_cast_to_ENUM_XPR_CONTROL_M(int32_T input);

static int32_T safe_cast_to_ENUM_XPR_ERROR_STA(int32_T input);

static void L4_MABX_enter_atomic_INITIAL(void);

static void L4_MABX_Calculate_abc(void);

static void L4_MABX_CalculateAlternate_abc(void);

static void L4_MABX_CalculateAcceleration34(void);

static int32_T safe_cast_to_ENUM_CAN_STATUS_DI(int32_T input);



/* Lookup Binary Search Utility BINARYSEARCH_real_T */

void BINARYSEARCH_real_T(uint32_T *piLeft, uint32_T *piRght, real_T u, const

  real_T *pData, uint32_T iHi)

{

  /* Find the location of current input value in the data table. */

  *piLeft = 0U;

  *piRght = iHi;

  if (u <= pData[0] ) {

    /* Less than or equal to the smallest point in the table. */

    *piRght = 0U;

  } else if (u >= pData[iHi] ) {

    /* Greater than or equal to the largest point in the table. */

    *piLeft = iHi;

  } else {

    uint32_T i;



    /* Do a binary search. */

    while (( *piRght - *piLeft ) > 1U ) {

      /* Get the average of the left and right indices using to Floor rounding. */

      i = (*piLeft + *piRght) >> 1;



      /* Move either the right index or the left index so that */

      /*  LeftDataPoint <= CurrentValue < RightDataPoint */

      if (u < pData[i] ) {

        *piRght = i;

      } else {

        *piLeft = i;

      }

    }

  }

}



/* Lookup Utility LookUp_real_T_real_T */

void LookUp_real_T_real_T(real_T *pY, const real_T *pYData, real_T u, const

  real_T *pUData, uint32_T iHi)

{

  uint32_T iLeft;

  uint32_T iRght;

  BINARYSEARCH_real_T( &(iLeft), &(iRght), u, pUData, iHi);



  {

    real_T lambda;

    if (pUData[iRght] > pUData[iLeft] ) {

      real_T num;

      real_T den;

      den = pUData[iRght];

      den -= pUData[iLeft];

      num = u;

      num -= pUData[iLeft];

      lambda = num / den;

    } else {

      lambda = 0.0;

    }



    {

      real_T yLeftCast;

      real_T yRghtCast;

      yLeftCast = pYData[iLeft];

      yRghtCast = pYData[iRght];

      yLeftCast += lambda * ( yRghtCast - yLeftCast );

      (*pY) = yLeftCast;

    }

  }

}



real_T look1_binlcapw(real_T u0, const real_T bp0[], const real_T table[],

                      uint32_T maxIndex)

{

  real_T y;

  real_T frac;

  uint32_T iRght;

  uint32_T iLeft;

  uint32_T bpIdx;



  /* Lookup 1-D

     Search method: 'binary'

     Use previous index: 'off'

     Interpolation method: 'Linear point-slope'

     Extrapolation method: 'Clip'

     Use last breakpoint for index at or above upper limit: 'on'

     Remove protection against out-of-range input in generated code: 'off'

   */

  /* Prelookup - Index and Fraction

     Index Search method: 'binary'

     Extrapolation method: 'Clip'

     Use previous index: 'off'

     Use last breakpoint for index at or above upper limit: 'on'

     Remove protection against out-of-range input in generated code: 'off'

   */

  if (u0 <= bp0[0U]) {

    iLeft = 0U;

    frac = 0.0;

  } else if (u0 < bp0[maxIndex]) {

    /* Binary Search */

    bpIdx = maxIndex >> 1U;

    iLeft = 0U;

    iRght = maxIndex;

    while (iRght - iLeft > 1U) {

      if (u0 < bp0[bpIdx]) {

        iRght = bpIdx;

      } else {

        iLeft = bpIdx;

      }



      bpIdx = (iRght + iLeft) >> 1U;

    }



    frac = (u0 - bp0[iLeft]) / (bp0[iLeft + 1U] - bp0[iLeft]);

  } else {

    iLeft = maxIndex;

    frac = 0.0;

  }



  /* Interpolation 1-D

     Interpolation method: 'Linear point-slope'

     Use last breakpoint for index at or above upper limit: 'on'

     Overflow mode: 'portable wrapping'

   */

  if (iLeft == maxIndex) {

    y = table[iLeft];

  } else {

    y = (table[iLeft + 1U] - table[iLeft]) * frac + table[iLeft];

  }



  return y;

}



real_T look2_binlcapw(real_T u0, real_T u1, const real_T bp0[], const real_T

                      bp1[], const real_T table[], const uint32_T maxIndex[],

                      uint32_T stride)

{

  real_T y;

  real_T frac;

  uint32_T bpIndices[2];

  real_T fractions[2];

  real_T yR_1d;

  uint32_T iRght;

  uint32_T bpIdx;

  uint32_T iLeft;



  /* Lookup 2-D

     Search method: 'binary'

     Use previous index: 'off'

     Interpolation method: 'Linear point-slope'

     Extrapolation method: 'Clip'

     Use last breakpoint for index at or above upper limit: 'on'

     Remove protection against out-of-range input in generated code: 'off'

   */

  /* Prelookup - Index and Fraction

     Index Search method: 'binary'

     Extrapolation method: 'Clip'

     Use previous index: 'off'

     Use last breakpoint for index at or above upper limit: 'on'

     Remove protection against out-of-range input in generated code: 'off'

   */

  if (u0 <= bp0[0U]) {

    iLeft = 0U;

    frac = 0.0;

  } else if (u0 < bp0[maxIndex[0U]]) {

    /* Binary Search */

    bpIdx = maxIndex[0U] >> 1U;

    iLeft = 0U;

    iRght = maxIndex[0U];

    while (iRght - iLeft > 1U) {

      if (u0 < bp0[bpIdx]) {

        iRght = bpIdx;

      } else {

        iLeft = bpIdx;

      }



      bpIdx = (iRght + iLeft) >> 1U;

    }



    frac = (u0 - bp0[iLeft]) / (bp0[iLeft + 1U] - bp0[iLeft]);

  } else {

    iLeft = maxIndex[0U];

    frac = 0.0;

  }



  fractions[0U] = frac;

  bpIndices[0U] = iLeft;



  /* Prelookup - Index and Fraction

     Index Search method: 'binary'

     Extrapolation method: 'Clip'

     Use previous index: 'off'

     Use last breakpoint for index at or above upper limit: 'on'

     Remove protection against out-of-range input in generated code: 'off'

   */

  if (u1 <= bp1[0U]) {

    iLeft = 0U;

    frac = 0.0;

  } else if (u1 < bp1[maxIndex[1U]]) {

    /* Binary Search */

    bpIdx = maxIndex[1U] >> 1U;

    iLeft = 0U;

    iRght = maxIndex[1U];

    while (iRght - iLeft > 1U) {

      if (u1 < bp1[bpIdx]) {

        iRght = bpIdx;

      } else {

        iLeft = bpIdx;

      }



      bpIdx = (iRght + iLeft) >> 1U;

    }



    frac = (u1 - bp1[iLeft]) / (bp1[iLeft + 1U] - bp1[iLeft]);

  } else {

    iLeft = maxIndex[1U];

    frac = 0.0;

  }



  /* Interpolation 2-D

     Interpolation method: 'Linear point-slope'

     Use last breakpoint for index at or above upper limit: 'on'

     Overflow mode: 'portable wrapping'

   */

  bpIdx = iLeft * stride + bpIndices[0U];

  if (bpIndices[0U] == maxIndex[0U]) {

    y = table[bpIdx];

  } else {

    y = (table[bpIdx + 1U] - table[bpIdx]) * fractions[0U] + table[bpIdx];

  }



  if (iLeft == maxIndex[1U]) {

  } else {

    bpIdx += stride;

    if (bpIndices[0U] == maxIndex[0U]) {

      yR_1d = table[bpIdx];

    } else {

      yR_1d = (table[bpIdx + 1U] - table[bpIdx]) * fractions[0U] + table[bpIdx];

    }



    y += (yR_1d - y) * frac;

  }



  return y;

}



real_T look1_binlxpw(real_T u0, const real_T bp0[], const real_T table[],

                     uint32_T maxIndex)

{

  real_T frac;

  uint32_T iRght;

  uint32_T iLeft;

  uint32_T bpIdx;



  /* Lookup 1-D

     Search method: 'binary'

     Use previous index: 'off'

     Interpolation method: 'Linear point-slope'

     Extrapolation method: 'Linear'

     Use last breakpoint for index at or above upper limit: 'off'

     Remove protection against out-of-range input in generated code: 'off'

   */

  /* Prelookup - Index and Fraction

     Index Search method: 'binary'

     Extrapolation method: 'Linear'

     Use previous index: 'off'

     Use last breakpoint for index at or above upper limit: 'off'

     Remove protection against out-of-range input in generated code: 'off'

   */

  if (u0 <= bp0[0U]) {

    iLeft = 0U;

    frac = (u0 - bp0[0U]) / (bp0[1U] - bp0[0U]);

  } else if (u0 < bp0[maxIndex]) {

    /* Binary Search */

    bpIdx = maxIndex >> 1U;

    iLeft = 0U;

    iRght = maxIndex;

    while (iRght - iLeft > 1U) {

      if (u0 < bp0[bpIdx]) {

        iRght = bpIdx;

      } else {

        iLeft = bpIdx;

      }



      bpIdx = (iRght + iLeft) >> 1U;

    }



    frac = (u0 - bp0[iLeft]) / (bp0[iLeft + 1U] - bp0[iLeft]);

  } else {

    iLeft = maxIndex - 1U;

    frac = (u0 - bp0[maxIndex - 1U]) / (bp0[maxIndex] - bp0[maxIndex - 1U]);

  }



  /* Interpolation 1-D

     Interpolation method: 'Linear point-slope'

     Use last breakpoint for index at or above upper limit: 'off'

     Overflow mode: 'portable wrapping'

   */

  return (table[iLeft + 1U] - table[iLeft]) * frac + table[iLeft];

}



/*

 * Output and update for atomic system:

 *    '<S82>/If_Then_Else'

 *    '<S83>/If_Then_Else'

 *    '<S83>/If_Then_Else1'

 *    '<S89>/If_Then_Else'

 *    '<S89>/If_Then_Else1'

 *    '<S90>/If_Then_Else'

 *    '<S90>/If_Then_Else1'

 *    '<S121>/If_Then_Else'

 *    '<S124>/If_Then_Else'

 *    '<S126>/If_Then_Else'

 *    ...

 */

void L4_MABX_If_Then_Else(boolean_T rtu_If, real_T rtu_Then, real_T rtu_Else,

  B_If_Then_Else_L4_MABX_T *localB)

{

  /* Switch: '<S86>/Switch' */

  if (rtu_If) {

    localB->Switch = rtu_Then;

  } else {

    localB->Switch = rtu_Else;

  }



  /* End of Switch: '<S86>/Switch' */

}



/*

 * System initialize for enable system:

 *    '<S112>/Calculate_D_term'

 *    '<S150>/Calculate_D_term'

 *    '<S244>/Calculate_D_term'

 */

void L4_MA_Calculate_D_term_Init(B_Calculate_D_term_L4_MABX_T *localB,

  DW_Calculate_D_term_L4_MABX_T *localDW, P_Calculate_D_term_L4_MABX_T *localP)

{

  /* InitializeConditions for UnitDelay: '<S121>/Unit_Delay1' */

  localDW->Unit_Delay1_DSTATE = localP->Unit_Delay1_InitialCondition;



  /* InitializeConditions for UnitDelay: '<S121>/Unit_Delay2' */

  localDW->Unit_Delay2_DSTATE = localP->Unit_Delay2_InitialCondition;



  /* InitializeConditions for UnitDelay: '<S122>/FixPt Unit Delay2' */

  localDW->FixPtUnitDelay2_DSTATE = localP->FixPtUnitDelay2_InitialConditio;



  /* InitializeConditions for UnitDelay: '<S122>/FixPt Unit Delay1' */

  localDW->FixPtUnitDelay1_DSTATE = localP->FixPtUnitDelay1_InitialConditio;



  /* SystemInitialize for Outport: '<S116>/GPID_d_term' */

  localB->Subtract = localP->GPID_d_term_Y0;

}



/*

 * System reset for enable system:

 *    '<S112>/Calculate_D_term'

 *    '<S150>/Calculate_D_term'

 *    '<S244>/Calculate_D_term'

 */

void L4_M_Calculate_D_term_Reset(DW_Calculate_D_term_L4_MABX_T *localDW,

  P_Calculate_D_term_L4_MABX_T *localP)

{

  /* InitializeConditions for UnitDelay: '<S121>/Unit_Delay1' */

  localDW->Unit_Delay1_DSTATE = localP->Unit_Delay1_InitialCondition;



  /* InitializeConditions for UnitDelay: '<S121>/Unit_Delay2' */

  localDW->Unit_Delay2_DSTATE = localP->Unit_Delay2_InitialCondition;



  /* InitializeConditions for UnitDelay: '<S122>/FixPt Unit Delay2' */

  localDW->FixPtUnitDelay2_DSTATE = localP->FixPtUnitDelay2_InitialConditio;



  /* InitializeConditions for UnitDelay: '<S122>/FixPt Unit Delay1' */

  localDW->FixPtUnitDelay1_DSTATE = localP->FixPtUnitDelay1_InitialConditio;

}



/*

 * Disable for enable system:

 *    '<S112>/Calculate_D_term'

 *    '<S150>/Calculate_D_term'

 *    '<S244>/Calculate_D_term'

 */

void L4_Calculate_D_term_Disable(B_Calculate_D_term_L4_MABX_T *localB,

  DW_Calculate_D_term_L4_MABX_T *localDW, P_Calculate_D_term_L4_MABX_T *localP)

{

  /* Disable for Outport: '<S116>/GPID_d_term' */

  localB->Subtract = localP->GPID_d_term_Y0;

  localDW->Calculate_D_term_MODE = false;

}



/*

 * Start for enable system:

 *    '<S112>/Calculate_D_term'

 *    '<S150>/Calculate_D_term'

 *    '<S244>/Calculate_D_term'

 */

void L4_M_Calculate_D_term_Start(DW_Calculate_D_term_L4_MABX_T *localDW)

{

  localDW->Calculate_D_term_MODE = false;

}



/*

 * Outputs for enable system:

 *    '<S112>/Calculate_D_term'

 *    '<S150>/Calculate_D_term'

 *    '<S244>/Calculate_D_term'

 */

void L4_MABX_Calculate_D_term(boolean_T rtu_Enable, real_T rtu_GPID_Kd, real_T

  rtu_GPID_dT, boolean_T rtu_F_GPID_reset_gov, real_T rtu_GPID_control_error,

  real_T rtu_GPID_T_filt_d, B_Calculate_D_term_L4_MABX_T *localB,

  DW_Calculate_D_term_L4_MABX_T *localDW, P_Calculate_D_term_L4_MABX_T *localP)

{

  real_T maxV;

  real_T u1;

  real_T u2;



  /* Outputs for Enabled SubSystem: '<S112>/Calculate_D_term' incorporates:

   *  EnablePort: '<S116>/Enable'

   */

  if (rtu_Enable) {

    if (!localDW->Calculate_D_term_MODE) {

      L4_M_Calculate_D_term_Reset(localDW, localP);

      localDW->Calculate_D_term_MODE = true;

    }



    /* UnitDelay: '<S121>/Unit_Delay1' */

    localB->Unit_Delay1 = localDW->Unit_Delay1_DSTATE;



    /* Logic: '<S121>/Logical Operator' */

    localB->LogicalOperator = (rtu_F_GPID_reset_gov || localB->Unit_Delay1);



    /* MinMax: '<S121>/MinMax1' */

    if ((rtu_GPID_dT > rtu_GPID_T_filt_d) || rtIsNaN(rtu_GPID_T_filt_d)) {

      maxV = rtu_GPID_dT;

    } else {

      maxV = rtu_GPID_T_filt_d;

    }



    localB->MinMax1 = maxV;



    /* End of MinMax: '<S121>/MinMax1' */



    /* Saturate: '<S121>/Saturation' */

    maxV = localB->MinMax1;

    u1 = localP->Saturation_LowerSat;

    u2 = localP->Saturation_UpperSat;

    if (maxV > u2) {

      localB->Saturation = u2;

    } else if (maxV < u1) {

      localB->Saturation = u1;

    } else {

      localB->Saturation = maxV;

    }



    /* End of Saturate: '<S121>/Saturation' */



    /* Product: '<S121>/Divide' */

    localB->Divide = rtu_GPID_dT / localB->Saturation;



    /* Product: '<S121>/Product2' */

    localB->Product2 = rtu_GPID_control_error * localB->Divide;



    /* Sum: '<S121>/Subtract1' incorporates:

     *  Constant: '<S121>/Constant1'

     */

    localB->Subtract1 = localP->Constant1_Value - localB->Divide;



    /* UnitDelay: '<S121>/Unit_Delay2' */

    localB->Unit_Delay2 = localDW->Unit_Delay2_DSTATE;



    /* Product: '<S121>/Product1' */

    localB->Product1 = localB->Subtract1 * localB->Unit_Delay2;



    /* Sum: '<S121>/Add1' */

    localB->Add1 = localB->Product2 + localB->Product1;



    /* Outputs for Atomic SubSystem: '<S121>/If_Then_Else' */

    L4_MABX_If_Then_Else(localB->LogicalOperator, rtu_GPID_control_error,

                         localB->Add1, &localB->If_Then_Else);



    /* End of Outputs for SubSystem: '<S121>/If_Then_Else' */



    /* Product: '<S116>/Divide' */

    localB->Divide_k = localB->If_Then_Else.Switch / rtu_GPID_dT * rtu_GPID_Kd;



    /* UnitDelay: '<S122>/FixPt Unit Delay2' */

    localB->FixPtUnitDelay2 = localDW->FixPtUnitDelay2_DSTATE;



    /* Logic: '<S122>/FixPt Logical Operator' */

    localB->FixPtLogicalOperator = (uint8_T)(rtu_F_GPID_reset_gov ||

      (localB->FixPtUnitDelay2 != 0));



    /* UnitDelay: '<S122>/FixPt Unit Delay1' */

    localB->Xold = localDW->FixPtUnitDelay1_DSTATE;



    /* Switch: '<S122>/Init' */

    if (localB->FixPtLogicalOperator != 0) {

      localB->Init = localB->Divide_k;

    } else {

      localB->Init = localB->Xold;

    }



    /* End of Switch: '<S122>/Init' */



    /* Sum: '<S116>/Subtract' */

    localB->Subtract = localB->Divide_k - localB->Init;



    /* Switch: '<S122>/Reset' */

    localB->Xnew = localB->Divide_k;

  } else {

    if (localDW->Calculate_D_term_MODE) {

      L4_Calculate_D_term_Disable(localB, localDW, localP);

    }

  }



  /* End of Outputs for SubSystem: '<S112>/Calculate_D_term' */

}



/*

 * Update for enable system:

 *    '<S112>/Calculate_D_term'

 *    '<S150>/Calculate_D_term'

 *    '<S244>/Calculate_D_term'

 */

void L4__Calculate_D_term_Update(B_Calculate_D_term_L4_MABX_T *localB,

  DW_Calculate_D_term_L4_MABX_T *localDW, P_Calculate_D_term_L4_MABX_T *localP)

{

  /* Update for Enabled SubSystem: '<S112>/Calculate_D_term' incorporates:

   *  EnablePort: '<S116>/Enable'

   */

  if (localDW->Calculate_D_term_MODE) {

    /* Update for UnitDelay: '<S121>/Unit_Delay1' incorporates:

     *  Constant: '<S121>/Constant'

     */

    localDW->Unit_Delay1_DSTATE = localP->Constant_Value;



    /* Update for UnitDelay: '<S121>/Unit_Delay2' */

    localDW->Unit_Delay2_DSTATE = localB->If_Then_Else.Switch;



    /* Update for UnitDelay: '<S122>/FixPt Unit Delay2' incorporates:

     *  Constant: '<S122>/FixPt Constant'

     */

    localDW->FixPtUnitDelay2_DSTATE = localP->FixPtConstant_Value;



    /* Update for UnitDelay: '<S122>/FixPt Unit Delay1' */

    localDW->FixPtUnitDelay1_DSTATE = localB->Xnew;

  }



  /* End of Update for SubSystem: '<S112>/Calculate_D_term' */

}



/*

 * Output and update for atomic system:

 *    '<S126>/If_Then_Else3'

 *    '<S164>/If_Then_Else3'

 *    '<S258>/If_Then_Else3'

 *    '<S472>/If_Then_Else'

 *    '<S1082>/If_Then_Else'

 */

void L4_MABX_If_Then_Else3(boolean_T rtu_If, boolean_T rtu_Then, boolean_T

  rtu_Else, B_If_Then_Else_L4_MABX_c_T *localB)

{

  /* Switch: '<S134>/Switch' */

  if (rtu_If) {

    localB->Switch = rtu_Then;

  } else {

    localB->Switch = rtu_Else;

  }



  /* End of Switch: '<S134>/Switch' */

}



/*

 * System initialize for enable system:

 *    '<S112>/Calculate_I_term'

 *    '<S150>/Calculate_I_term'

 *    '<S244>/Calculate_I_term'

 */

void L4_MA_Calculate_I_term_Init(B_Calculate_I_term_L4_MABX_T *localB,

  DW_Calculate_I_term_L4_MABX_T *localDW, P_Calculate_I_term_L4_MABX_T *localP)

{

  /* InitializeConditions for UnitDelay: '<S128>/FixPt Unit Delay2' */

  localDW->FixPtUnitDelay2_DSTATE = localP->FixPtUnitDelay2_InitialConditio;



  /* InitializeConditions for UnitDelay: '<S128>/FixPt Unit Delay1' */

  localDW->FixPtUnitDelay1_DSTATE = localP->FixPtUnitDelay1_InitialConditio;



  /* InitializeConditions for UnitDelay: '<S117>/Unit_Delay' */

  localDW->Unit_Delay_DSTATE = localP->Unit_Delay_InitialCondition;



  /* SystemInitialize for Enabled SubSystem: '<S117>/Initialize_integral_term' */

  /* SystemInitialize for Outport: '<S125>/GPID_i_sum_error_init' */

  localB->Subtract2 = localP->GPID_i_sum_error_init_Y0;



  /* End of SystemInitialize for SubSystem: '<S117>/Initialize_integral_term' */



  /* SystemInitialize for Outport: '<S117>/GPID_i_term' */

  localB->If_Then_Else.Switch = localP->GPID_i_term_Y0;



  /* SystemInitialize for Outport: '<S117>/F_GPID_hold_i_term' */

  localB->LogicalOperator2 = localP->F_GPID_hold_i_term_Y0;

}



/*

 * System reset for enable system:

 *    '<S112>/Calculate_I_term'

 *    '<S150>/Calculate_I_term'

 *    '<S244>/Calculate_I_term'

 */

void L4_M_Calculate_I_term_Reset(DW_Calculate_I_term_L4_MABX_T *localDW,

  P_Calculate_I_term_L4_MABX_T *localP)

{

  /* InitializeConditions for UnitDelay: '<S128>/FixPt Unit Delay2' */

  localDW->FixPtUnitDelay2_DSTATE = localP->FixPtUnitDelay2_InitialConditio;



  /* InitializeConditions for UnitDelay: '<S128>/FixPt Unit Delay1' */

  localDW->FixPtUnitDelay1_DSTATE = localP->FixPtUnitDelay1_InitialConditio;



  /* InitializeConditions for UnitDelay: '<S117>/Unit_Delay' */

  localDW->Unit_Delay_DSTATE = localP->Unit_Delay_InitialCondition;

}



/*

 * Disable for enable system:

 *    '<S112>/Calculate_I_term'

 *    '<S150>/Calculate_I_term'

 *    '<S244>/Calculate_I_term'

 */

void L4_Calculate_I_term_Disable(B_Calculate_I_term_L4_MABX_T *localB,

  DW_Calculate_I_term_L4_MABX_T *localDW, P_Calculate_I_term_L4_MABX_T *localP)

{

  /* Disable for Outport: '<S117>/GPID_i_term' */

  localB->If_Then_Else.Switch = localP->GPID_i_term_Y0;



  /* Disable for Outport: '<S117>/F_GPID_hold_i_term' */

  localB->LogicalOperator2 = localP->F_GPID_hold_i_term_Y0;

  localDW->Calculate_I_term_MODE = false;

}



/*

 * Start for enable system:

 *    '<S112>/Calculate_I_term'

 *    '<S150>/Calculate_I_term'

 *    '<S244>/Calculate_I_term'

 */

void L4_M_Calculate_I_term_Start(DW_Calculate_I_term_L4_MABX_T *localDW)

{

  localDW->Calculate_I_term_MODE = false;

}



/*

 * Outputs for enable system:

 *    '<S112>/Calculate_I_term'

 *    '<S150>/Calculate_I_term'

 *    '<S244>/Calculate_I_term'

 */

void L4_MABX_Calculate_I_term(boolean_T rtu_Enable, real_T rtu_GPID_p_term,

  real_T rtu_GPID_Ki, real_T rtu_GPID_actual_system_output, real_T

  rtu_GPID_control_error, boolean_T rtu_F_GPID_reset_gov, real_T rtu_GPID_dT,

  real_T rtu_GPID_feed_forward, boolean_T rtu_F_GPID_aw_cond_integration, real_T

  rtu_GPID_aw_hysteresis, boolean_T rtu_F_GPID_aw_hold_i_term, real_T

  rtu_GPID_output_unlim_prev, B_Calculate_I_term_L4_MABX_T *localB,

  DW_Calculate_I_term_L4_MABX_T *localDW, P_Calculate_I_term_L4_MABX_T *localP)

{

  /* Outputs for Enabled SubSystem: '<S112>/Calculate_I_term' incorporates:

   *  EnablePort: '<S117>/Enable'

   */

  if (rtu_Enable) {

    if (!localDW->Calculate_I_term_MODE) {

      L4_M_Calculate_I_term_Reset(localDW, localP);

      localDW->Calculate_I_term_MODE = true;

    }



    /* Outputs for Enabled SubSystem: '<S117>/Initialize_integral_term' incorporates:

     *  EnablePort: '<S125>/Enable'

     */

    if (rtu_F_GPID_reset_gov) {

      /* Product: '<S125>/Product' */

      localB->Product_j = rtu_GPID_Ki * rtu_GPID_dT * rtu_GPID_control_error;



      /* Sum: '<S125>/Subtract' */

      localB->Subtract_g = rtu_GPID_actual_system_output - rtu_GPID_feed_forward;



      /* Sum: '<S125>/Subtract1' */

      localB->Subtract1_k = localB->Subtract_g - rtu_GPID_p_term;



      /* Sum: '<S125>/Subtract2' */

      localB->Subtract2 = localB->Subtract1_k - localB->Product_j;

    }



    /* End of Outputs for SubSystem: '<S117>/Initialize_integral_term' */



    /* UnitDelay: '<S128>/FixPt Unit Delay2' */

    localB->FixPtUnitDelay2 = localDW->FixPtUnitDelay2_DSTATE;



    /* Logic: '<S128>/FixPt Logical Operator' */

    localB->FixPtLogicalOperator = (uint8_T)(rtu_F_GPID_reset_gov ||

      (localB->FixPtUnitDelay2 != 0));



    /* UnitDelay: '<S128>/FixPt Unit Delay1' */

    localB->Xold = localDW->FixPtUnitDelay1_DSTATE;



    /* Switch: '<S128>/Init' */

    if (localB->FixPtLogicalOperator != 0) {

      localB->Init = localB->Subtract2;

    } else {

      localB->Init = localB->Xold;

    }



    /* End of Switch: '<S128>/Init' */



    /* Product: '<S124>/Product1' */

    localB->Product1 = rtu_GPID_Ki * rtu_GPID_control_error * rtu_GPID_dT;



    /* Sum: '<S124>/Add' */

    localB->Add = localB->Init + localB->Product1;



    /* UnitDelay: '<S117>/Unit_Delay' */

    localB->Unit_Delay = localDW->Unit_Delay_DSTATE;



    /* Outputs for Atomic SubSystem: '<S126>/If_Then_Else' */



    /* Constant: '<S126>/Constant' */

    L4_MABX_If_Then_Else(rtu_F_GPID_reset_gov, localP->Constant_Value,

                         localB->Unit_Delay, &localB->If_Then_Else_c);



    /* End of Outputs for SubSystem: '<S126>/If_Then_Else' */



    /* Outputs for Atomic SubSystem: '<S126>/If_Then_Else2' */

    L4_MABX_If_Then_Else(rtu_F_GPID_reset_gov, rtu_GPID_actual_system_output,

                         rtu_GPID_output_unlim_prev, &localB->If_Then_Else2);



    /* End of Outputs for SubSystem: '<S126>/If_Then_Else2' */



    /* Outputs for Atomic SubSystem: '<S126>/If_Then_Else1' */

    L4_MABX_If_Then_Else(rtu_F_GPID_aw_cond_integration,

                         localB->If_Then_Else_c.Switch,

                         localB->If_Then_Else2.Switch, &localB->If_Then_Else1);



    /* End of Outputs for SubSystem: '<S126>/If_Then_Else1' */



    /* Product: '<S126>/Product' */

    localB->Product = rtu_GPID_Ki * rtu_GPID_control_error *

      localB->If_Then_Else1.Switch;



    /* RelationalOperator: '<S129>/Compare' incorporates:

     *  Constant: '<S129>/Constant'

     */

    localB->Compare = (localB->Product > localP->Constant_Value_p);



    /* RelationalOperator: '<S130>/Compare' incorporates:

     *  Constant: '<S130>/Constant'

     */

    localB->Compare_n = (localB->Unit_Delay >= localP->Constant_Value_b);



    /* Sum: '<S126>/Subtract' */

    localB->Subtract = localB->If_Then_Else2.Switch -

      rtu_GPID_actual_system_output;



    /* RelationalOperator: '<S126>/Relational Operator1' */

    localB->RelationalOperator1 = (localB->Subtract > rtu_GPID_aw_hysteresis);



    /* Sum: '<S126>/Subtract1' */

    localB->Subtract1 = rtu_GPID_actual_system_output -

      localB->If_Then_Else2.Switch;



    /* RelationalOperator: '<S126>/Relational Operator2' */

    localB->RelationalOperator2 = (localB->Subtract1 > rtu_GPID_aw_hysteresis);



    /* Outputs for Atomic SubSystem: '<S126>/If_Then_Else3' */

    L4_MABX_If_Then_Else3(localB->Compare_n, localB->RelationalOperator1,

                          localB->RelationalOperator2, &localB->If_Then_Else3);



    /* End of Outputs for SubSystem: '<S126>/If_Then_Else3' */



    /* Logic: '<S126>/Logical Operator1' */

    localB->LogicalOperator1 = (localB->Compare && localB->If_Then_Else3.Switch);



    /* Logic: '<S126>/Logical Operator2' */

    localB->LogicalOperator2 = (localB->LogicalOperator1 ||

      rtu_F_GPID_aw_hold_i_term);



    /* Outputs for Atomic SubSystem: '<S124>/If_Then_Else' */

    L4_MABX_If_Then_Else(localB->LogicalOperator2, localB->Init, localB->Add,

                         &localB->If_Then_Else);



    /* End of Outputs for SubSystem: '<S124>/If_Then_Else' */



    /* Switch: '<S128>/Reset' */

    if (rtu_F_GPID_reset_gov) {

      localB->Xnew = localB->Subtract2;

    } else {

      localB->Xnew = localB->If_Then_Else.Switch;

    }



    /* End of Switch: '<S128>/Reset' */

  } else {

    if (localDW->Calculate_I_term_MODE) {

      L4_Calculate_I_term_Disable(localB, localDW, localP);

    }

  }



  /* End of Outputs for SubSystem: '<S112>/Calculate_I_term' */

}



/*

 * Update for enable system:

 *    '<S112>/Calculate_I_term'

 *    '<S150>/Calculate_I_term'

 *    '<S244>/Calculate_I_term'

 */

void L4__Calculate_I_term_Update(B_Calculate_I_term_L4_MABX_T *localB,

  DW_Calculate_I_term_L4_MABX_T *localDW, P_Calculate_I_term_L4_MABX_T *localP)

{

  /* Update for Enabled SubSystem: '<S112>/Calculate_I_term' incorporates:

   *  EnablePort: '<S117>/Enable'

   */

  if (localDW->Calculate_I_term_MODE) {

    /* Update for UnitDelay: '<S128>/FixPt Unit Delay2' incorporates:

     *  Constant: '<S128>/FixPt Constant'

     */

    localDW->FixPtUnitDelay2_DSTATE = localP->FixPtConstant_Value;



    /* Update for UnitDelay: '<S128>/FixPt Unit Delay1' */

    localDW->FixPtUnitDelay1_DSTATE = localB->Xnew;



    /* Update for UnitDelay: '<S117>/Unit_Delay' */

    localDW->Unit_Delay_DSTATE = localB->If_Then_Else.Switch;

  }



  /* End of Update for SubSystem: '<S112>/Calculate_I_term' */

}



/* Output and update for atomic system: '<S104>/If_Then_Else' */

void L4_MABX_If_Then_Else_l(boolean_T rtu_If, boolean_T rtu_Then, boolean_T

  rtu_Else, B_If_Then_Else_L4_MABX_m_T *localB)

{

  /* Switch: '<S182>/Switch' */

  if (rtu_If) {

    localB->Switch = rtu_Then;

  } else {

    localB->Switch = rtu_Else;

  }



  /* End of Switch: '<S182>/Switch' */

}



/*

 * Output and update for atomic system:

 *    '<S183>/If_Then_Else'

 *    '<S183>/If_Then_Else1'

 *    '<S184>/If_Then_Else'

 *    '<S184>/If_Then_Else1'

 *    '<S280>/If_Then_Else'

 *    '<S281>/If_Then_Else'

 *    '<S281>/If_Then_Else1'

 *    '<S366>/If_Then_Else'

 *    '<S363>/If_Then_Else'

 *    '<S372>/If_Then_Else'

 *    ...

 */

void L4_MABX_If_Then_Else_g(boolean_T rtu_If, real_T rtu_Then, real_T rtu_Else,

  B_If_Then_Else_L4_MABX_k_T *localB)

{

  /* Switch: '<S185>/Switch' */

  if (rtu_If) {

    localB->Switch = rtu_Then;

  } else {

    localB->Switch = rtu_Else;

  }



  /* End of Switch: '<S185>/Switch' */

}



/*

 * Output and update for atomic system:

 *    '<S301>/If_Then_Else'

 *    '<S316>/If_Then_Else'

 */

void L4_MABX_If_Then_Else_k(real_T rtu_If, real_T rtu_Then, real_T rtu_Else,

  B_If_Then_Else_L4_MABX_n_T *localB)

{

  /* Switch: '<S303>/Switch' */

  if (rtu_If != 0.0) {

    localB->Switch = rtu_Then;

  } else {

    localB->Switch = rtu_Else;

  }



  /* End of Switch: '<S303>/Switch' */

}



/* Output and update for atomic system: '<S356>/If_Then_Else' */

void L4_MABX_If_Then_Else_m(boolean_T rtu_If, real_T rtu_Then, real_T rtu_Then_l,

  real_T rtu_Then_f, real_T rtu_Else, real_T rtu_Else_i, real_T rtu_Else_k,

  B_If_Then_Else_L4_MABX_h_T *localB)

{

  /* Switch: '<S358>/Switch' */

  if (rtu_If) {

    localB->Vehicle_speed_target = rtu_Then;

    localB->Vehicle_speed = rtu_Then_l;

    localB->Distance_m = rtu_Then_f;

  } else {

    localB->Vehicle_speed_target = rtu_Else;

    localB->Vehicle_speed = rtu_Else_i;

    localB->Distance_m = rtu_Else_k;

  }



  /* End of Switch: '<S358>/Switch' */

}



/* System initialize for function-call system: '<S405>/Background_Task' */

void L4_MAB_Background_Task_Init(void)

{

  /* InitializeConditions for S-Function (dsa_tcpip_bkg_sfcn): '<S415>/dsa_tcpip_bkg_sfcn' */

  /* Level2 S-Function Block: '<S415>/dsa_tcpip_bkg_sfcn' (dsa_tcpip_bkg_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[0];

    sfcnInitializeConditions(rts);

    if (ssGetErrorStatus(rts) != (NULL))

      return;

  }

}



/* System reset for function-call system: '<S405>/Background_Task' */

void L4_MA_Background_Task_Reset(void)

{

  /* InitializeConditions for S-Function (dsa_tcpip_bkg_sfcn): '<S415>/dsa_tcpip_bkg_sfcn' */

  /* Level2 S-Function Block: '<S415>/dsa_tcpip_bkg_sfcn' (dsa_tcpip_bkg_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[0];

    sfcnInitializeConditions(rts);

    if (ssGetErrorStatus(rts) != (NULL))

      return;

  }

}



/* Start for function-call system: '<S405>/Background_Task' */

void L4_MA_Background_Task_Start(void)

{

  /* Start for S-Function (dsa_tcpip_bkg_sfcn): '<S415>/dsa_tcpip_bkg_sfcn' */

  /* Level2 S-Function Block: '<S415>/dsa_tcpip_bkg_sfcn' (dsa_tcpip_bkg_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[0];

    sfcnStart(rts);

    if (ssGetErrorStatus(rts) != (NULL))

      return;

  }

}



/* Output and update for function-call system: '<S405>/Background_Task' */

void L4_MABX_Background_Task(void)

{

  /* S-Function (dsa_tcpip_bkg_sfcn): '<S415>/dsa_tcpip_bkg_sfcn' */



  /* Level2 S-Function Block: '<S415>/dsa_tcpip_bkg_sfcn' (dsa_tcpip_bkg_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[0];

    sfcnOutputs(rts,9);

  }

}



/* Termination for function-call system: '<S405>/Background_Task' */

void L4_MAB_Background_Task_Term(void)

{

  /* Terminate for S-Function (dsa_tcpip_bkg_sfcn): '<S415>/dsa_tcpip_bkg_sfcn' */

  /* Level2 S-Function Block: '<S415>/dsa_tcpip_bkg_sfcn' (dsa_tcpip_bkg_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[0];

    sfcnTerminate(rts);

  }

}



/* System initialize for function-call system: '<S405>/IRQ_Level_2_SW_INT' */

void L4__IRQ_Level_2_SW_INT_Init(void)

{

  /* InitializeConditions for S-Function (dsa_tcpip_irq_l2_sfcn): '<S416>/dsa_tcpip_irq_l2_sfcn' */

  /* Level2 S-Function Block: '<S416>/dsa_tcpip_irq_l2_sfcn' (dsa_tcpip_irq_l2_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[1];

    sfcnInitializeConditions(rts);

    if (ssGetErrorStatus(rts) != (NULL))

      return;

  }

}



/* System reset for function-call system: '<S405>/IRQ_Level_2_SW_INT' */

void L4_IRQ_Level_2_SW_INT_Reset(void)

{

  /* InitializeConditions for S-Function (dsa_tcpip_irq_l2_sfcn): '<S416>/dsa_tcpip_irq_l2_sfcn' */

  /* Level2 S-Function Block: '<S416>/dsa_tcpip_irq_l2_sfcn' (dsa_tcpip_irq_l2_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[1];

    sfcnInitializeConditions(rts);

    if (ssGetErrorStatus(rts) != (NULL))

      return;

  }

}



/* Start for function-call system: '<S405>/IRQ_Level_2_SW_INT' */

void L4_IRQ_Level_2_SW_INT_Start(void)

{

  /* Start for S-Function (dsa_tcpip_irq_l2_sfcn): '<S416>/dsa_tcpip_irq_l2_sfcn' */

  /* Level2 S-Function Block: '<S416>/dsa_tcpip_irq_l2_sfcn' (dsa_tcpip_irq_l2_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[1];

    sfcnStart(rts);

    if (ssGetErrorStatus(rts) != (NULL))

      return;

  }

}



/* Output and update for function-call system: '<S405>/IRQ_Level_2_SW_INT' */

void L4_MABX_IRQ_Level_2_SW_INT(void)

{

  /* S-Function (dsa_tcpip_irq_l2_sfcn): '<S416>/dsa_tcpip_irq_l2_sfcn' */



  /* Level2 S-Function Block: '<S416>/dsa_tcpip_irq_l2_sfcn' (dsa_tcpip_irq_l2_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[1];

    sfcnOutputs(rts,10);

  }

}



/* Termination for function-call system: '<S405>/IRQ_Level_2_SW_INT' */

void L4__IRQ_Level_2_SW_INT_Term(void)

{

  /* Terminate for S-Function (dsa_tcpip_irq_l2_sfcn): '<S416>/dsa_tcpip_irq_l2_sfcn' */

  /* Level2 S-Function Block: '<S416>/dsa_tcpip_irq_l2_sfcn' (dsa_tcpip_irq_l2_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[1];

    sfcnTerminate(rts);

  }

}



/* System initialize for function-call system: '<S417>/Tcp Input Processing' */

void L4__TcpInputProcessing_Init(void)

{

  /* SystemInitialize for S-Function (rti_commonblock): '<S419>/S-Function1' incorporates:

   *  SubSystem: '<S405>/IRQ_Level_2_SW_INT'

   */

  L4__IRQ_Level_2_SW_INT_Init();



  /* End of SystemInitialize for S-Function (rti_commonblock): '<S419>/S-Function1' */

}



/* System reset for function-call system: '<S417>/Tcp Input Processing' */

void L4_TcpInputProcessing_Reset(void)

{

  /* SystemReset for S-Function (rti_commonblock): '<S419>/S-Function1' incorporates:

   *  SubSystem: '<S405>/IRQ_Level_2_SW_INT'

   */

  L4_IRQ_Level_2_SW_INT_Reset();



  /* End of SystemReset for S-Function (rti_commonblock): '<S419>/S-Function1' */

}



/* Start for function-call system: '<S417>/Tcp Input Processing' */

void L4_TcpInputProcessing_Start(void)

{

  /* Start for S-Function (rti_commonblock): '<S419>/S-Function1' incorporates:

   *  SubSystem: '<S405>/IRQ_Level_2_SW_INT'

   */

  L4_IRQ_Level_2_SW_INT_Start();



  /* End of Start for S-Function (rti_commonblock): '<S419>/S-Function1' */

}



/* Output and update for function-call system: '<S417>/Tcp Input Processing' */

void L4_MABX_TcpInputProcessing(void)

{

  /* S-Function (rti_commonblock): '<S419>/S-Function1' */



  /* This comment workarounds a code generation problem */



  /* dSPACE Software Interrupt Block: <S417>/Tcp Input Processing */

  rtk_schedule_task(S_SOFTTASK,0);



  /* End of Outputs for S-Function (rti_commonblock): '<S419>/S-Function1' */

}



/*

 * Forced non-inlined (FNI) function call stub

 * for '<S417>/Tcp Input Processing'

 */

boolean_T L4_MABX_TcpInputProcessingFNI(RT_MODEL_L4_MABX_T *const L4_MABX_M,

  int_T controlPortIdx, int_T tid)

{

  L4_MABX_TcpInputProcessing();

  UNUSED_PARAMETER(L4_MABX_M);

  UNUSED_PARAMETER(controlPortIdx);

  UNUSED_PARAMETER(tid);

  return (1);

}



/*

 * Forced non-inlined (FNI) function call stub

 * for '<S417>/Tcp Input Processing'

 */

boolean_T L4_TcpInputProcessing_ResetFNI(RT_MODEL_L4_MABX_T *const L4_MABX_M,

  int_T controlPortIdx, int_T tid)

{

  UNUSED_PARAMETER(L4_MABX_M);

  UNUSED_PARAMETER(controlPortIdx);

  UNUSED_PARAMETER(tid);

  return (1);

}



/* Termination for function-call system: '<S417>/Tcp Input Processing' */

void L4__TcpInputProcessing_Term(void)

{

  /* Terminate for S-Function (rti_commonblock): '<S419>/S-Function1' incorporates:

   *  SubSystem: '<S405>/IRQ_Level_2_SW_INT'

   */

  L4__IRQ_Level_2_SW_INT_Term();



  /* End of Terminate for S-Function (rti_commonblock): '<S419>/S-Function1' */

}



/* System initialize for function-call system: '<S405>/Interrupt_Task' */

void L4_MABX_Interrupt_Task_Init(void)

{

  /* InitializeConditions for S-Function (dsa_tcpip_irq_l1_sfcn): '<S417>/dsa_tcpip_irq_l1_sfcn' */



  /* Level2 S-Function Block: '<S417>/dsa_tcpip_irq_l1_sfcn' (dsa_tcpip_irq_l1_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[2];

    sfcnInitializeConditions(rts);

    if (ssGetErrorStatus(rts) != (NULL))

      return;

  }



  /* End of InitializeConditions for S-Function (dsa_tcpip_irq_l1_sfcn): '<S417>/dsa_tcpip_irq_l1_sfcn' */



  /* SystemInitialize for S-Function (dsa_tcpip_irq_l1_sfcn): '<S417>/dsa_tcpip_irq_l1_sfcn' incorporates:

   *  SubSystem: '<S417>/Tcp Input Processing'

   */

  L4__TcpInputProcessing_Init();



  /* End of SystemInitialize for S-Function (dsa_tcpip_irq_l1_sfcn): '<S417>/dsa_tcpip_irq_l1_sfcn' */

}



/* System reset for function-call system: '<S405>/Interrupt_Task' */

void L4_MAB_Interrupt_Task_Reset(void)

{

  /* InitializeConditions for S-Function (dsa_tcpip_irq_l1_sfcn): '<S417>/dsa_tcpip_irq_l1_sfcn' */



  /* Level2 S-Function Block: '<S417>/dsa_tcpip_irq_l1_sfcn' (dsa_tcpip_irq_l1_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[2];

    sfcnInitializeConditions(rts);

    if (ssGetErrorStatus(rts) != (NULL))

      return;

  }



  /* End of InitializeConditions for S-Function (dsa_tcpip_irq_l1_sfcn): '<S417>/dsa_tcpip_irq_l1_sfcn' */



  /* SystemReset for S-Function (dsa_tcpip_irq_l1_sfcn): '<S417>/dsa_tcpip_irq_l1_sfcn' incorporates:

   *  SubSystem: '<S417>/Tcp Input Processing'

   */

  L4_TcpInputProcessing_Reset();



  /* End of SystemReset for S-Function (dsa_tcpip_irq_l1_sfcn): '<S417>/dsa_tcpip_irq_l1_sfcn' */

}



/* Start for function-call system: '<S405>/Interrupt_Task' */

void L4_MAB_Interrupt_Task_Start(void)

{

  /* Start for S-Function (dsa_tcpip_irq_l1_sfcn): '<S417>/dsa_tcpip_irq_l1_sfcn' incorporates:

   *  SubSystem: '<S417>/Tcp Input Processing'

   */

  L4_TcpInputProcessing_Start();



  /* Level2 S-Function Block: '<S417>/dsa_tcpip_irq_l1_sfcn' (dsa_tcpip_irq_l1_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[2];

    sfcnStart(rts);

    if (ssGetErrorStatus(rts) != (NULL))

      return;

  }



  /* End of Start for S-Function (dsa_tcpip_irq_l1_sfcn): '<S417>/dsa_tcpip_irq_l1_sfcn' */

}



/* Output and update for function-call system: '<S405>/Interrupt_Task' */

void L4_MABX_Interrupt_Task(void)

{

  /* S-Function (dsa_tcpip_irq_l1_sfcn): '<S417>/dsa_tcpip_irq_l1_sfcn' */



  /* Level2 S-Function Block: '<S417>/dsa_tcpip_irq_l1_sfcn' (dsa_tcpip_irq_l1_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[2];

    sfcnOutputs(rts,11);

  }



  /* End of Outputs for S-Function (dsa_tcpip_irq_l1_sfcn): '<S417>/dsa_tcpip_irq_l1_sfcn' */

}



/* Termination for function-call system: '<S405>/Interrupt_Task' */

void L4_MABX_Interrupt_Task_Term(void)

{

  /* Terminate for S-Function (dsa_tcpip_irq_l1_sfcn): '<S417>/dsa_tcpip_irq_l1_sfcn' */



  /* Level2 S-Function Block: '<S417>/dsa_tcpip_irq_l1_sfcn' (dsa_tcpip_irq_l1_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[2];

    sfcnTerminate(rts);

  }



  /* End of Terminate for S-Function (dsa_tcpip_irq_l1_sfcn): '<S417>/dsa_tcpip_irq_l1_sfcn' */



  /* Terminate for S-Function (dsa_tcpip_irq_l1_sfcn): '<S417>/dsa_tcpip_irq_l1_sfcn' incorporates:

   *  SubSystem: '<S417>/Tcp Input Processing'

   */

  L4__TcpInputProcessing_Term();



  /* End of Terminate for S-Function (dsa_tcpip_irq_l1_sfcn): '<S417>/dsa_tcpip_irq_l1_sfcn' */

}



/* Output and update for atomic system: '<S750>/If_Then_Else' */

void L4_MABX_If_Then_Else_kn(boolean_T rtu_If, real_T rtu_Then, real_T rtu_Else)

{

  /* Switch: '<S771>/Switch' */

  if (rtu_If) {

    Pedal_pwm_position = rtu_Then;

  } else {

    Pedal_pwm_position = rtu_Else;

  }



  /* End of Switch: '<S771>/Switch' */

}



/* System initialize for function-call system: '<S423>/IncrementTimer' */

void L4_MABX_IncrementTimer_Init(void)

{

  /* InitializeConditions for UnitDelay: '<S853>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_k = L4_MABX_P.Unit_Delay_InitialCondition_n;



  /* SystemInitialize for Outport: '<S853>/Out1' */

  L4_MABX_B.Add = L4_MABX_P.Out1_Y0_c;

}



/* System reset for function-call system: '<S423>/IncrementTimer' */

void L4_MAB_IncrementTimer_Reset(void)

{

  /* InitializeConditions for UnitDelay: '<S853>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_k = L4_MABX_P.Unit_Delay_InitialCondition_n;

}



/* Output and update for function-call system: '<S423>/IncrementTimer' */

void L4_MABX_IncrementTimer(void)

{

  /* UnitDelay: '<S853>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_k = L4_MABX_DW.Unit_Delay_DSTATE_k;



  /* Sum: '<S853>/Add' incorporates:

   *  Constant: '<S853>/Constant1'

   */

  L4_MABX_B.Add = L4_MABX_P.Constant1_Value_pc + L4_MABX_B.Unit_Delay_k;



  /* Update for UnitDelay: '<S853>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_k = L4_MABX_B.Add;

}



/*

 * Output and update for enable system:

 *    '<S983>/ALL_CTRL_DISABLED'

 *    '<S983>/DEFAULT_TRQ_CTRL_MODE'

 *    '<S983>/EXT_TRQ_CTRL_MODE_A'

 *    '<S983>/EXT_TRQ_CTRL_MODE_B'

 *    '<S983>/EXT_TRQ_CTRL_MODE_C'

 */

void L4_MABX_ALL_CTRL_DISABLED(boolean_T rtu_Enable, int32_T *rty_Out1,

  P_ALL_CTRL_DISABLED_L4_MABX_T *localP)

{

  /* Outputs for Enabled SubSystem: '<S983>/ALL_CTRL_DISABLED' incorporates:

   *  EnablePort: '<S998>/Enable'

   */

  if (rtu_Enable) {

    /* SignalConversion: '<S998>/OutportBufferForOut1' incorporates:

     *  Constant: '<S998>/Constant'

     */

    *rty_Out1 = localP->Constant_Value;

  }



  /* End of Outputs for SubSystem: '<S983>/ALL_CTRL_DISABLED' */

}



/* Output and update for atomic system: '<S1021>/If_Then_Else' */

void L4_MABX_If_Then_Else_b(boolean_T rtu_If, real_T rtu_Then,

  ENUM_XBR_EBI_MODE_T rtu_Then_i, ENUM_XBR_PRIORITY_T rtu_Then_a,

  ENUM_XBR_CONTROL_MODE_T rtu_Then_h, ENUM_XBR_PASS_THROUGH_ACTIVE_T rtu_Then_j,

  real_T rtu_Then_c, real_T rtu_Then_o, real_T rtu_Else, ENUM_XBR_EBI_MODE_T

  rtu_Else_a, ENUM_XBR_PRIORITY_T rtu_Else_d, ENUM_XBR_CONTROL_MODE_T

  rtu_Else_do, ENUM_XBR_PASS_THROUGH_ACTIVE_T rtu_Else_b, real_T rtu_Else_k,

  real_T rtu_Else_bk, B_If_Then_Else_L4_MABX_p_T *localB)

{

  /* Switch: '<S1045>/Switch' */

  if (rtu_If) {

    localB->XBRExternalAccelDemand = rtu_Then;

    localB->XBREnduranceBrakeIntegrationMod = rtu_Then_i;

    localB->XBRPriority = rtu_Then_a;

    localB->XBRControlMode = rtu_Then_h;

    localB->XBRPassThroughActive = rtu_Then_j;

    localB->XBRUrgency = rtu_Then_c;

    localB->XBRPassThroughEnabled = rtu_Then_o;

  } else {

    localB->XBRExternalAccelDemand = rtu_Else;

    localB->XBREnduranceBrakeIntegrationMod = rtu_Else_a;

    localB->XBRPriority = rtu_Else_d;

    localB->XBRControlMode = rtu_Else_do;

    localB->XBRPassThroughActive = rtu_Else_b;

    localB->XBRUrgency = rtu_Else_k;

    localB->XBRPassThroughEnabled = rtu_Else_bk;

  }



  /* End of Switch: '<S1045>/Switch' */

}



static int32_T safe_cast_to_ENUM_XPR_CONTROL_M(int32_T input)

{

  int32_T y;



  /* Initialize output value to default value for ENUM_XPR_CONTROL_MODE_T (NO_BRAKE_DEMAND) */

  y = 0;

  if (((input >= 0) && (input <= 3)) || ((input >= 13) && (input <= 15))) {

    /* Set output value to input value if it is a member of ENUM_XPR_CONTROL_MODE_T */

    y = input;

  }



  return y;

}



static int32_T safe_cast_to_ENUM_XPR_ERROR_STA(int32_T input)

{

  int32_T y;



  /* Initialize output value to default value for ENUM_XPR_ERROR_STATE_T (XPR_OK) */

  y = 0;

  if ((input >= 0) && (input <= 3)) {

    /* Set output value to input value if it is a member of ENUM_XPR_ERROR_STATE_T */

    y = input;

  }



  return y;

}



/* Function for Chart: '<S211>/Relay_control_state_machine' */

static void L4_MABX_enter_atomic_INITIAL(void)

{

  /* Entry 'INITIAL': '<S218>:12' */

  L4_MABX_B.F_Ignition_relay_command_i = false;

  L4_MABX_B.F_Inverter_relay_command_p = false;

  L4_MABX_B.F_MABX_relay_command_n = false;

  L4_MABX_B.F_Sensor_relay_command_k = false;

  L4_MABX_DW.IGN_RELAY_ON_DELAY_SECS_APV =

    L4_MABX_B.TmpSignalConversionAtSFunctionI[0];

  L4_MABX_DW.INVERTER_RELAY_ON_DELAY_SECS_AP =

    L4_MABX_B.TmpSignalConversionAtSFunctionI[1];

  L4_MABX_DW.MABX_RELAY_ON_DELAY_SECS_APV =

    L4_MABX_B.TmpSignalConversionAtSFunctionI[2];

  L4_MABX_DW.SENSOR_RELAY_ON_DELAY_SECS_APV =

    L4_MABX_B.TmpSignalConversionAtSFunctionI[3];

  L4_MABX_DW.IGN_RELAY_OFF_DELAY_SECS_APV =

    L4_MABX_B.TmpSignalConversionAtSFunctio_k[0];

  L4_MABX_DW.INVERTER_RELAY_OFF_DELAY_SECS_A =

    L4_MABX_B.TmpSignalConversionAtSFunctio_k[1];

  L4_MABX_DW.MABX_RELAY_OFF_DELAY_SECS_APV =

    L4_MABX_B.TmpSignalConversionAtSFunctio_k[2];

  L4_MABX_DW.SENSOR_RELAY_OFF_DELAY_SECS_APV =

    L4_MABX_B.TmpSignalConversionAtSFunctio_k[3];

}



real_T rt_atan2d_snf(real_T u0, real_T u1)

{

  real_T y;

  int32_T tmp;

  int32_T tmp_0;

  if (rtIsNaN(u0) || rtIsNaN(u1)) {

    y = (rtNaN);

  } else if (rtIsInf(u0) && rtIsInf(u1)) {

    if (u1 > 0.0) {

      tmp = 1;

    } else {

      tmp = -1;

    }



    if (u0 > 0.0) {

      tmp_0 = 1;

    } else {

      tmp_0 = -1;

    }



    y = atan2(tmp_0, tmp);

  } else if (u1 == 0.0) {

    if (u0 > 0.0) {

      y = RT_PI / 2.0;

    } else if (u0 < 0.0) {

      y = -(RT_PI / 2.0);

    } else {

      y = 0.0;

    }

  } else {

    y = atan2(u0, u1);

  }



  return y;

}



real_T rt_powd_snf(real_T u0, real_T u1)

{

  real_T y;

  real_T tmp;

  real_T tmp_0;

  if (rtIsNaN(u0) || rtIsNaN(u1)) {

    y = (rtNaN);

  } else {

    tmp = fabs(u0);

    tmp_0 = fabs(u1);

    if (rtIsInf(u1)) {

      if (tmp == 1.0) {

        y = 1.0;

      } else if (tmp > 1.0) {

        if (u1 > 0.0) {

          y = (rtInf);

        } else {

          y = 0.0;

        }

      } else if (u1 > 0.0) {

        y = 0.0;

      } else {

        y = (rtInf);

      }

    } else if (tmp_0 == 0.0) {

      y = 1.0;

    } else if (tmp_0 == 1.0) {

      if (u1 > 0.0) {

        y = u0;

      } else {

        y = 1.0 / u0;

      }

    } else if (u1 == 2.0) {

      y = u0 * u0;

    } else if ((u1 == 0.5) && (u0 >= 0.0)) {

      y = sqrt(u0);

    } else if ((u0 < 0.0) && (u1 > floor(u1))) {

      y = (rtNaN);

    } else {

      y = pow(u0, u1);

    }

  }



  return y;

}



/* Function for Chart: '<S350>/VehicleSpeedSetpointDynamicCalculation' */

static void L4_MABX_Calculate_abc(void)

{

  /* MATLAB Function 'Calculate_abc': '<S365>:158' */

  /* Graphical Function 'Calculate_abc': '<S365>:158' */

  /* '<S365>:160:1' */

  L4_MABX_DW.a = L4_MABX_DW.Jerk56 - L4_MABX_DW.Jerk12;



  /* '<S365>:160:1' */

  L4_MABX_DW.b = ((L4_MABX_DW.AccelerationFinalLimited * L4_MABX_DW.Jerk12 -

                   L4_MABX_DW.AccelerationInitialLimited * L4_MABX_DW.Jerk56) -

                  L4_MABX_DW.Jerk12 * L4_MABX_DW.Jerk56 * L4_MABX_DW.TimeFinal) *

    2.0;



  /* '<S365>:160:3' */

  L4_MABX_DW.c = (2.0 * L4_MABX_DW.Jerk12 * L4_MABX_DW.Jerk56 *

                  (L4_MABX_DW.VelocityFinalLimited -

                   L4_MABX_DW.VelocityInitialLimited) +

                  L4_MABX_DW.AccelerationInitialLimited *

                  L4_MABX_DW.AccelerationInitialLimited * L4_MABX_DW.Jerk56) -

    L4_MABX_DW.AccelerationFinalLimited * L4_MABX_DW.AccelerationFinalLimited *

    L4_MABX_DW.Jerk12;

}



/* Function for Chart: '<S350>/VehicleSpeedSetpointDynamicCalculation' */

static void L4_MABX_CalculateAlternate_abc(void)

{

  /* MATLAB Function 'CalculateAlternate_abc': '<S365>:286' */

  /* Graphical Function 'CalculateAlternate_abc': '<S365>:286' */

  /* '<S365>:285:1' */

  L4_MABX_DW.a = 1.0;



  /* '<S365>:285:1' */

  L4_MABX_DW.b = ((L4_MABX_DW.TimeFinal - 0.005) * L4_MABX_DW.Jerk56 -

                  L4_MABX_DW.AccelerationFinalLimited) * 2.0;



  /* '<S365>:285:3' */

  L4_MABX_DW.c = 2.0 * L4_MABX_DW.Jerk56 * (L4_MABX_DW.VelocityInitialLimited -

    L4_MABX_DW.VelocityFinalLimited) + L4_MABX_DW.AccelerationFinalLimited *

    L4_MABX_DW.AccelerationFinalLimited;

}



/* Function for Chart: '<S350>/VehicleSpeedSetpointDynamicCalculation' */

static void L4_MABX_CalculateAcceleration34(void)

{

  real_T u;

  real_T u0;

  real_T u1;



  /* MATLAB Function 'CalculateAcceleration34': '<S365>:167' */

  /* Graphical Function 'CalculateAcceleration34': '<S365>:167' */

  /* '<S365>:186:1' */

  /* '<S365>:186:5' */

  /* '<S365>:186:8' */

  u = L4_MABX_DW.Jerk12;

  if (u < 0.0) {

    u = -1.0;

  } else if (u > 0.0) {

    u = 1.0;

  } else if (u == 0.0) {

    u = 0.0;

  } else {

    u = (rtNaN);

  }



  u0 = fabs(L4_MABX_DW.Jerk12);

  u1 = fabs(((((L4_MABX_DW.AccelerationInitialLimited *

                L4_MABX_DW.AccelerationFinalLimited -

                L4_MABX_DW.AccelerationInitialLimited * L4_MABX_DW.Jerk56 *

                L4_MABX_DW.TimeFinal) + (L4_MABX_DW.VelocityFinalLimited -

    L4_MABX_DW.VelocityInitialLimited) * L4_MABX_DW.Jerk56) * 2.0 -

              L4_MABX_DW.AccelerationInitialLimited *

              L4_MABX_DW.AccelerationInitialLimited) -

             L4_MABX_DW.AccelerationFinalLimited *

             L4_MABX_DW.AccelerationFinalLimited) /

            (((L4_MABX_DW.VelocityFinalLimited -

               L4_MABX_DW.VelocityInitialLimited) -

              L4_MABX_DW.AccelerationFinalLimited * L4_MABX_DW.TimeFinal) * 2.0

             + L4_MABX_DW.TimeFinal * L4_MABX_DW.TimeFinal * L4_MABX_DW.Jerk56))

    + 0.001;

  if ((u0 > u1) || rtIsNaN(u1)) {

    u1 = u0;

  }



  L4_MABX_DW.Jerk12 = u * u1;



  /* '<S365>:186:11' */

  u1 = L4_MABX_DW.Jerk12;

  if ((10.0 < u1) || rtIsNaN(u1)) {

    u1 = 10.0;

  }



  if ((-10.0 > u1) || rtIsNaN(u1)) {

    L4_MABX_DW.Jerk12 = -10.0;

  } else {

    L4_MABX_DW.Jerk12 = u1;

  }



  /* '<S365>:186:11' */

  L4_MABX_Calculate_abc();



  /* '<S365>:187:1' */

  if (fabs(L4_MABX_DW.a) < 0.01) {

    /* '<S365>:188:1' */

    L4_MABX_DW.Jerk12 = L4_MABX_DW.Jerk56;



    /* '<S365>:188:1' */

    L4_MABX_Calculate_abc();



    /* '<S365>:188:1' */

    L4_MABX_DW.Acceleration34 = -L4_MABX_DW.c / L4_MABX_DW.b;



    /* '<S365>:188:2' */

    L4_MABX_DW.AlternateMethod = false;

  } else {

    /* '<S365>:224:1' */

    if (L4_MABX_DW.b * L4_MABX_DW.b <= 4.0 * L4_MABX_DW.a * L4_MABX_DW.c) {

      /* '<S365>:292:1' */

      L4_MABX_CalculateAlternate_abc();



      /* '<S365>:292:1' */

      L4_MABX_DW.Acceleration34 = -L4_MABX_DW.b / (2.0 * L4_MABX_DW.a);



      /* '<S365>:292:2' */

      L4_MABX_DW.AlternateMethod = true;

    } else {

      /* '<S365>:294:1' */

      L4_MABX_DW.Acceleration34 = (sqrt(L4_MABX_DW.b * L4_MABX_DW.b - 4.0 *

        L4_MABX_DW.a * L4_MABX_DW.c) + -L4_MABX_DW.b) / (2.0 * L4_MABX_DW.a);



      /* '<S365>:294:2' */

      L4_MABX_DW.AlternateMethod = false;

    }

  }

}



static int32_T safe_cast_to_ENUM_CAN_STATUS_DI(int32_T input)

{

  int32_T y;



  /* Initialize output value to default value for ENUM_CAN_STATUS_DIAG_T (ACTIVE) */

  y = 0;

  if ((input >= 0) && (input <= 2)) {

    /* Set output value to input value if it is a member of ENUM_CAN_STATUS_DIAG_T */

    y = input;

  }



  return y;

}



/* Model output function for TID0 */

void L4_MABX_output0(void)             /* Sample time: [0.01s, 0.0s] */

{

  int_T tid = 0;

  uint8_T starting_index;

  real_T AccelerationAverage;

  real_T DeltaTimeFinal;

  uint8_T j;

  real_T PositionFinalLimited;

  real_T Time56;

  real_T DeltaTime;

  uint32_T tmp;

  boolean_T zcEvent;

  int32_T i;

  uint32_T q0;

  uint16_T tmp_0;

  int8_T tmp_1;



  /* Update the flag to indicate when data transfers from

   *  Sample time: [0.01s, 0.0s] to Sample time: [0.02s, 0.0s]  */

  L4_MABX_M->Timing.perTaskSampleHits[1] =

    (L4_MABX_M->Timing.RateInteraction.TID0_1 == 0);

  (L4_MABX_M->Timing.RateInteraction.TID0_1)++;

  if ((L4_MABX_M->Timing.RateInteraction.TID0_1) > 1) {

    L4_MABX_M->Timing.RateInteraction.TID0_1 = 0;

  }



  /* Update the flag to indicate when data transfers from

   *  Sample time: [0.01s, 0.0s] to Sample time: [0.05s, 0.0s]  */

  L4_MABX_M->Timing.perTaskSampleHits[2] =

    (L4_MABX_M->Timing.RateInteraction.TID0_2 == 0);

  (L4_MABX_M->Timing.RateInteraction.TID0_2)++;

  if ((L4_MABX_M->Timing.RateInteraction.TID0_2) > 4) {

    L4_MABX_M->Timing.RateInteraction.TID0_2 = 0;

  }



  /* Update the flag to indicate when data transfers from

   *  Sample time: [0.01s, 0.0s] to Sample time: [0.1s, 0.0s]  */

  L4_MABX_M->Timing.perTaskSampleHits[3] =

    (L4_MABX_M->Timing.RateInteraction.TID0_3 == 0);

  (L4_MABX_M->Timing.RateInteraction.TID0_3)++;

  if ((L4_MABX_M->Timing.RateInteraction.TID0_3) > 9) {

    L4_MABX_M->Timing.RateInteraction.TID0_3 = 0;

  }



  /* Update the flag to indicate when data transfers from

   *  Sample time: [0.01s, 0.0s] to Sample time: [1.0s, 0.0s]  */

  L4_MABX_M->Timing.perTaskSampleHits[6] =

    (L4_MABX_M->Timing.RateInteraction.TID0_6 == 0);

  (L4_MABX_M->Timing.RateInteraction.TID0_6)++;

  if ((L4_MABX_M->Timing.RateInteraction.TID0_6) > 99) {

    L4_MABX_M->Timing.RateInteraction.TID0_6 = 0;

  }



  /* Update the flag to indicate when data transfers from

   *  Sample time: [0.01s, 0.0s] to Sample time: [5.0s, 0.0s]  */

  L4_MABX_M->Timing.perTaskSampleHits[7] =

    (L4_MABX_M->Timing.RateInteraction.TID0_7 == 0);

  (L4_MABX_M->Timing.RateInteraction.TID0_7)++;

  if ((L4_MABX_M->Timing.RateInteraction.TID0_7) > 499) {

    L4_MABX_M->Timing.RateInteraction.TID0_7 = 0;

  }



  /* Outputs for Enabled SubSystem: '<S503>/AIR1' incorporates:

   *  EnablePort: '<S504>/Enable'

   */

  /* Constant: '<S431>/Constant' */

  if (L4_MABX_P.Constant_Value_b0) {

    /* S-Function (rti_commonblock): '<S504>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "AIR1" Id:419343921 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEAE31].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEAE31].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o9_kh = 1.0;

        L4_MABX_B.SFunction1_o10_dt = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEAE31].timestamp;

        L4_MABX_B.SFunction1_o11_a3 = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEAE31].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEAE31].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "PneumaticSupplyPress" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_fw = 8 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "ParkingAnd_orTrailerAirPress" (8|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o2_ey = 8 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "ServiceBrakeCircuit1AirPress" (16|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o3_j1 = 8 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "ServiceBrakeCircuit2AirPress" (24|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o4_kv = 8 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "AuxEquipmentSupplyPress" (32|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o5_ki = 8 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "AirSuspensionSupplyPress" (40|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o6_jl = 8 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "AirCompressorStatus" (48|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o7_hj = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "PowertrainCircuitAirSupplyPress" (56|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o8_fg = 8 * ( ((real_T) CAN_Sgn.UnsignedSgn) );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o9_kh = 0.0;

      }

    }

  }



  /* End of Constant: '<S431>/Constant' */

  /* End of Outputs for SubSystem: '<S503>/AIR1' */



  /* Outputs for Enabled SubSystem: '<S505>/AMB' incorporates:

   *  EnablePort: '<S506>/Enable'

   */

  /* Constant: '<S432>/Constant' */

  if (L4_MABX_P.Constant_Value_bu) {

    /* S-Function (rti_commonblock): '<S506>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "AMB" Id:419362048 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEF500].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEF500].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o6_j0 = 1.0;

        L4_MABX_B.SFunction1_o7_m = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEF500].timestamp;

        L4_MABX_B.SFunction1_o8_i = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEF500].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEF500].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "BarometricPress" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_a5 = 0.5 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "CabInteriorTemp" (8|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o2_f2 = -273 + ( 0.03125 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) ) );



            /* ...... "AmbientAirTemp" (24|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o3_fp = -273 + ( 0.03125 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) ) );



            /* ...... "EngAirIntakeTemp" (40|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o4_i0 = -40 + ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "RoadSurfaceTemp" (48|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o5_gk = -273 + ( 0.03125 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) ) );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o6_j0 = 0.0;

      }

    }

  }



  /* End of Constant: '<S432>/Constant' */

  /* End of Outputs for SubSystem: '<S505>/AMB' */



  /* Outputs for Atomic SubSystem: '<S855>/CAN_TX_1000ms' */



  /* RateTransition: '<S875>/TmpRTBAtAIR1Inport1' */

  if (L4_MABX_M->Timing.RateInteraction.TID0_6 == 1) {

    L4_MABX_B.PneumaticSupplyPress = L4_MABX_B.SFunction1_o1_fw;

    L4_MABX_B.ParkingAnd_orTrailerAirPress = L4_MABX_B.SFunction1_o2_ey;

    L4_MABX_B.ServiceBrakeCircuit1AirPress = L4_MABX_B.SFunction1_o3_j1;

    L4_MABX_B.ServiceBrakeCircuit2AirPress = L4_MABX_B.SFunction1_o4_kv;

    L4_MABX_B.AuxEquipmentSupplyPress = L4_MABX_B.SFunction1_o5_ki;

    L4_MABX_B.AirSuspensionSupplyPress = L4_MABX_B.SFunction1_o6_jl;

    L4_MABX_B.AirCompressorStatus = L4_MABX_B.SFunction1_o7_hj;

    L4_MABX_B.PowertrainCircuitAirSupplyPress = L4_MABX_B.SFunction1_o8_fg;

    L4_MABX_B.BarometricPress_p = L4_MABX_B.SFunction1_o1_a5;

    L4_MABX_B.CabInteriorTemp = L4_MABX_B.SFunction1_o2_f2;

    L4_MABX_B.AmbientAirTemp_a = L4_MABX_B.SFunction1_o3_fp;

    L4_MABX_B.EngAirIntakeTemp = L4_MABX_B.SFunction1_o4_i0;

    L4_MABX_B.RoadSurfaceTemp = L4_MABX_B.SFunction1_o5_gk;

  }



  /* End of Outputs for SubSystem: '<S855>/CAN_TX_1000ms' */



  /* S-Function (rti_commonblock): '<S740>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* DataTypeConversion: '<S422>/EStopSwActive' */

  L4_MABX_B.EStopSwActive = L4_MABX_B.SFunction1_n3;



  /* Logic: '<S422>/Logical Operator1' */

  EStop = !L4_MABX_B.EStopSwActive;



  /* S-Function (rti_commonblock): '<S739>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* S-Function (sfix_bitop): '<S849>/Operator' */

  L4_MABX_B.Operator_ck = (L4_MABX_B.SFunction1_k &&

    (L4_MABX_P.Operator_BitMask_p2 != 0));



  /* DataTypeConversion: '<S849>/DataType' */

  L4_MABX_B.DataType_pt = L4_MABX_B.Operator_ck;



  /* Logic: '<S751>/Logical Operator' */

  L4_MABX_B.LogicalOperator = !L4_MABX_B.DataType_pt;



  /* S-Function (rti_commonblock): '<S741>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* S-Function (sfix_bitop): '<S850>/Operator' */

  L4_MABX_B.Operator_blr = (L4_MABX_B.SFunction1_j &&

    (L4_MABX_P.Operator_BitMask_hk != 0));



  /* DataTypeConversion: '<S850>/DataType' */

  L4_MABX_B.DataType_p0 = L4_MABX_B.Operator_blr;



  /* Logic: '<S751>/AND2' */

  L4_MABX_B.AND2 = (L4_MABX_B.LogicalOperator && L4_MABX_B.DataType_p0);



  /* Chart: '<S851>/Chart' */

  /* Gateway: DIGITAL/Signal Check/RationalityCheck/Chart */

  /* During: DIGITAL/Signal Check/RationalityCheck/Chart */

  if (L4_MABX_DW.is_active_c5_SUB_ECU_L4_MABX_HW == 0U) {

    /* Entry: DIGITAL/Signal Check/RationalityCheck/Chart */

    L4_MABX_DW.is_active_c5_SUB_ECU_L4_MABX_HW = 1U;



    /* Entry Internal: DIGITAL/Signal Check/RationalityCheck/Chart */

    /* Transition: '<S852>:6' */

    L4_MABX_DW.is_c5_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_init_p;



    /* Entry 'init': '<S852>:1' */

    L4_MABX_B.DiagPassed = false;

  } else {

    switch (L4_MABX_DW.is_c5_SUB_ECU_L4_MABX_HW_Interf) {

     case L4_MABX_IN_DiagPassed:

      /* During 'DiagPassed': '<S852>:4' */

      break;



     case L4_MABX_IN_SwitchOff:

      /* During 'SwitchOff': '<S852>:2' */

      if (L4_MABX_B.AND2) {

        /* Transition: '<S852>:8' */

        L4_MABX_DW.is_c5_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_DiagPassed;



        /* Entry 'DiagPassed': '<S852>:4' */

        L4_MABX_B.DiagPassed = true;

      }

      break;



     case L4_MABX_IN_SwitchOn:

      /* During 'SwitchOn': '<S852>:3' */

      if (!L4_MABX_B.AND2) {

        /* Transition: '<S852>:9' */

        L4_MABX_DW.is_c5_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_SwitchOff;

      }

      break;



     default:

      /* During 'init': '<S852>:1' */

      if (!L4_MABX_B.AND2) {

        /* Transition: '<S852>:5' */

        L4_MABX_DW.is_c5_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_SwitchOff;

      } else {

        /* Transition: '<S852>:7' */

        L4_MABX_DW.is_c5_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_SwitchOn;

      }

      break;

    }

  }



  /* End of Chart: '<S851>/Chart' */



  /* Switch: '<S751>/Switch' incorporates:

   *  Constant: '<S751>/OverrideOperatorEnableSW_Default'

   */

  if (L4_MABX_B.DiagPassed) {

    EnableSw = L4_MABX_B.AND2;

  } else {

    EnableSw = L4_MABX_P.OverrideOperatorEnableSW_Defaul;

  }



  /* End of Switch: '<S751>/Switch' */



  /* UnitDelay: '<S763>/Unit Delay' */

  L4_MABX_B.UnitDelay = L4_MABX_DW.UnitDelay_DSTATE;



  /* S-Function (rti_commonblock): '<S742>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* DataTypeConversion: '<S422>/StartPBActive' */

  L4_MABX_B.StartPBActive = L4_MABX_B.SFunction1_l;



  /* Logic: '<S422>/Logical Operator' */

  L4_MABX_B.LogicalOperator_g = !L4_MABX_B.StartPBActive;



  /* RelationalOperator: '<S765>/Compare' incorporates:

   *  Constant: '<S765>/Constant'

   */

  L4_MABX_B.Compare = ((int32_T)L4_MABX_B.LogicalOperator_g > (int32_T)

                       L4_MABX_P.Constant_Value_ju);



  /* UnitDelay: '<S761>/Delay Input1' */

  L4_MABX_B.Uk1_p = L4_MABX_DW.DelayInput1_DSTATE_i;



  /* RelationalOperator: '<S761>/FixPt Relational Operator' */

  L4_MABX_B.FixPtRelationalOperator = ((int32_T)L4_MABX_B.Compare > (int32_T)

    L4_MABX_B.Uk1_p);



  /* UnitDelay: '<S762>/Unit Delay' */

  L4_MABX_B.UnitDelay_k = L4_MABX_DW.UnitDelay_DSTATE_i;



  /* UnitDelay: '<S749>/Unit Delay' */

  L4_MABX_B.UnitDelay_b2 = L4_MABX_DW.UnitDelay_DSTATE_ix;



  /* RelationalOperator: '<S764>/Compare' incorporates:

   *  Constant: '<S764>/Constant'

   */

  L4_MABX_B.Compare_p = ((int32_T)L4_MABX_B.UnitDelay_b2 <= (int32_T)

    L4_MABX_P.Constant_Value_h3i);



  /* UnitDelay: '<S760>/Delay Input1' */

  L4_MABX_B.Uk1_e = L4_MABX_DW.DelayInput1_DSTATE_i5;



  /* RelationalOperator: '<S760>/FixPt Relational Operator' */

  L4_MABX_B.FixPtRelationalOperator_n = ((int32_T)L4_MABX_B.Compare_p > (int32_T)

    L4_MABX_B.Uk1_e);



  /* UnitDelay: '<S762>/Unit Delay1' */

  L4_MABX_B.UnitDelay1_c = L4_MABX_DW.UnitDelay1_DSTATE_p;



  /* Logic: '<S762>/OR1' */

  L4_MABX_B.OR1 = (L4_MABX_B.FixPtRelationalOperator_n || L4_MABX_B.UnitDelay1_c);



  /* Switch: '<S762>/Switch' incorporates:

   *  Constant: '<S762>/Constant0'

   */

  if (L4_MABX_B.OR1) {

    /* Sum: '<S762>/Sum' incorporates:

     *  Constant: '<S762>/Constant1'

     */

    L4_MABX_B.Sum_f = L4_MABX_B.UnitDelay_k + L4_MABX_P.Constant1_Value_pw;

    L4_MABX_B.Switch = L4_MABX_B.Sum_f;

  } else {

    L4_MABX_B.Switch = L4_MABX_P.Constant0_Value_e;

  }



  /* End of Switch: '<S762>/Switch' */



  /* RelationalOperator: '<S766>/Compare' incorporates:

   *  Constant: '<S766>/Constant'

   */

  L4_MABX_B.Compare_e = (L4_MABX_B.Switch > L4_MABX_P.Constant_Value_hg);



  /* Gain: '<S762>/Gain' incorporates:

   *  Constant: '<S422>/Constant3'

   */

  L4_MABX_B.Gain = L4_MABX_P.Gain_Gain_l * L4_MABX_P.Constant3_Value_ga;



  /* RelationalOperator: '<S762>/LessThanOrEqual' */

  L4_MABX_B.LessThanOrEqual = (L4_MABX_B.Switch <= L4_MABX_B.Gain);



  /* Logic: '<S762>/AND' */

  L4_MABX_B.AND = (L4_MABX_B.Compare_e && L4_MABX_B.LessThanOrEqual);



  /* Logic: '<S749>/NOT' */

  L4_MABX_B.NOT = !L4_MABX_B.AND;



  /* Logic: '<S749>/AND' */

  L4_MABX_B.AND_n = (L4_MABX_B.FixPtRelationalOperator && L4_MABX_B.NOT);



  /* UnitDelay: '<S763>/Unit Delay1' */

  L4_MABX_B.UnitDelay1_l = L4_MABX_DW.UnitDelay1_DSTATE_h;



  /* Logic: '<S763>/OR1' */

  L4_MABX_B.OR1_m = (L4_MABX_B.AND_n || L4_MABX_B.UnitDelay1_l);



  /* Switch: '<S763>/Switch' incorporates:

   *  Constant: '<S763>/Constant0'

   */

  if (L4_MABX_B.OR1_m) {

    /* Sum: '<S763>/Sum' incorporates:

     *  Constant: '<S763>/Constant1'

     */

    L4_MABX_B.Sum = L4_MABX_B.UnitDelay + L4_MABX_P.Constant1_Value_o0;

    L4_MABX_B.Switch_j = L4_MABX_B.Sum;

  } else {

    L4_MABX_B.Switch_j = L4_MABX_P.Constant0_Value_g;

  }



  /* End of Switch: '<S763>/Switch' */



  /* RelationalOperator: '<S767>/Compare' incorporates:

   *  Constant: '<S767>/Constant'

   */

  L4_MABX_B.Compare_ex = (L4_MABX_B.Switch_j > L4_MABX_P.Constant_Value_o4);



  /* Gain: '<S763>/Gain' incorporates:

   *  Constant: '<S422>/Constant2'

   */

  L4_MABX_B.Gain_e = L4_MABX_P.Gain_Gain_k4 * L4_MABX_P.Constant2_Value_m5;



  /* RelationalOperator: '<S763>/LessThanOrEqual' */

  L4_MABX_B.LessThanOrEqual_o = (L4_MABX_B.Switch_j <= L4_MABX_B.Gain_e);



  /* Logic: '<S763>/AND' */

  L4_MABX_B.AND_i = (L4_MABX_B.Compare_ex && L4_MABX_B.LessThanOrEqual_o);



  /* Logic: '<S749>/AND2' */

  EngagePB = (L4_MABX_B.AND_i && L4_MABX_B.NOT);



  /* S-Function (rti_commonblock): '<S744>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* DataTypeConversion: '<S422>/StartPBActive1' */

  L4_MABX_B.StartPBActive1 = L4_MABX_B.SFunction1_p;



  /* Logic: '<S422>/Logical Operator3' */

  BrakeSW = !L4_MABX_B.StartPBActive1;



  /* S-Function (rti_commonblock): '<S746>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* DataTypeConversion: '<S422>/Data Type Conversion2' */

  L4_MABX_B.Pedal_1_pwm_freq_raw_value = L4_MABX_B.SFunction1_o1;



  /* RelationalOperator: '<S797>/min_relop' incorporates:

   *  Constant: '<S769>/PWMAFreqRngMin'

   */

  L4_MABX_B.min_relop = (L4_MABX_P.PWMAFreqRngMin_Value <

    L4_MABX_B.Pedal_1_pwm_freq_raw_value);



  /* RelationalOperator: '<S797>/max_relop' incorporates:

   *  Constant: '<S769>/PWMAFreqRngMax'

   */

  L4_MABX_B.max_relop = (L4_MABX_B.Pedal_1_pwm_freq_raw_value <

    L4_MABX_P.PWMAFreqRngMax_Value);



  /* Logic: '<S797>/conjunction' */

  L4_MABX_B.conjunction = (L4_MABX_B.min_relop && L4_MABX_B.max_relop);



  /* UnitDelay: '<S802>/FixPt Unit Delay2' */

  L4_MABX_B.FixPtUnitDelay2 = L4_MABX_DW.FixPtUnitDelay2_DSTATE;



  /* UnitDelay: '<S802>/FixPt Unit Delay1' */

  L4_MABX_B.Xold = L4_MABX_DW.FixPtUnitDelay1_DSTATE;



  /* Switch: '<S802>/Init' incorporates:

   *  Constant: '<S769>/PWMAFreqRngFaultLimMin'

   */

  if (L4_MABX_B.FixPtUnitDelay2 != 0) {

    L4_MABX_B.Init = L4_MABX_P.PWMAFreqRngFaultLimMin_Value;

  } else {

    L4_MABX_B.Init = L4_MABX_B.Xold;

  }



  /* End of Switch: '<S802>/Init' */



  /* Sum: '<S798>/FixPt Sum1' incorporates:

   *  Constant: '<S798>/FixPt Constant'

   */

  L4_MABX_B.FixPtSum1 = L4_MABX_B.Init - L4_MABX_P.FixPtConstant_Value_b;



  /* Sum: '<S801>/FixPt Sum1' incorporates:

   *  Constant: '<S801>/FixPt Constant'

   */

  L4_MABX_B.FixPtSum1_m = L4_MABX_B.Init + L4_MABX_P.FixPtConstant_Value_o;



  /* Outputs for Atomic SubSystem: '<S785>/If_Then_Else3' */

  L4_MABX_If_Then_Else(L4_MABX_B.conjunction, L4_MABX_B.FixPtSum1,

                       L4_MABX_B.FixPtSum1_m, &L4_MABX_B.If_Then_Else3_d);



  /* End of Outputs for SubSystem: '<S785>/If_Then_Else3' */



  /* RelationalOperator: '<S799>/Relational Operator1' incorporates:

   *  Constant: '<S769>/PWMAFreqRngFaultLimMax'

   */

  L4_MABX_B.RelationalOperator1 = (L4_MABX_B.If_Then_Else3_d.Switch >=

    L4_MABX_P.PWMAFreqRngFaultLimMax_Value);



  /* RelationalOperator: '<S799>/Relational Operator' incorporates:

   *  Constant: '<S769>/PWMAFreqRngFaultLimMin'

   */

  L4_MABX_B.RelationalOperator = (L4_MABX_B.If_Then_Else3_d.Switch <=

    L4_MABX_P.PWMAFreqRngFaultLimMin_Value);



  /* Outputs for Atomic SubSystem: '<S799>/If_Then_Else1' */



  /* Constant: '<S769>/PWMAFreqRngFaultLimMin' */

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator,

                       L4_MABX_P.PWMAFreqRngFaultLimMin_Value,

                       L4_MABX_B.If_Then_Else3_d.Switch,

                       &L4_MABX_B.If_Then_Else1_b);



  /* End of Outputs for SubSystem: '<S799>/If_Then_Else1' */



  /* Outputs for Atomic SubSystem: '<S799>/If_Then_Else' */



  /* Constant: '<S769>/PWMAFreqRngFaultLimMax' */

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator1,

                       L4_MABX_P.PWMAFreqRngFaultLimMax_Value,

                       L4_MABX_B.If_Then_Else1_b.Switch,

                       &L4_MABX_B.If_Then_Else_a);



  /* End of Outputs for SubSystem: '<S799>/If_Then_Else' */



  /* RelationalOperator: '<S785>/Relational Operator9' incorporates:

   *  Constant: '<S769>/PWMAFreqRngFaultLimMin'

   */

  L4_MABX_B.F_Fault_Soft = (L4_MABX_B.If_Then_Else_a.Switch !=

    L4_MABX_P.PWMAFreqRngFaultLimMin_Value);



  /* Gain: '<S422>/Gain' */

  L4_MABX_B.Gain_l = L4_MABX_P.Gain_Gain_pu * L4_MABX_B.SFunction1_o2;



  /* DataTypeConversion: '<S422>/Data Type Conversion9' */

  L4_MABX_B.Pedal_1_pwm_dc_raw_value = L4_MABX_B.Gain_l;



  /* RelationalOperator: '<S789>/min_relop' incorporates:

   *  Constant: '<S769>/PWMADCRngMin'

   */

  L4_MABX_B.min_relop_e = (L4_MABX_P.PWMADCRngMin_Value <

    L4_MABX_B.Pedal_1_pwm_dc_raw_value);



  /* RelationalOperator: '<S789>/max_relop' incorporates:

   *  Constant: '<S769>/PWMADCRngMax'

   */

  L4_MABX_B.max_relop_c = (L4_MABX_B.Pedal_1_pwm_dc_raw_value <

    L4_MABX_P.PWMADCRngMax_Value);



  /* Logic: '<S789>/conjunction' */

  L4_MABX_B.conjunction_p = (L4_MABX_B.min_relop_e && L4_MABX_B.max_relop_c);



  /* UnitDelay: '<S794>/FixPt Unit Delay2' */

  L4_MABX_B.FixPtUnitDelay2_n = L4_MABX_DW.FixPtUnitDelay2_DSTATE_d;



  /* UnitDelay: '<S794>/FixPt Unit Delay1' */

  L4_MABX_B.Xold_j = L4_MABX_DW.FixPtUnitDelay1_DSTATE_d;



  /* Switch: '<S794>/Init' incorporates:

   *  Constant: '<S769>/PWMADCRngFaultLimMin'

   */

  if (L4_MABX_B.FixPtUnitDelay2_n != 0) {

    L4_MABX_B.Init_f = L4_MABX_P.PWMADCRngFaultLimMin_Value;

  } else {

    L4_MABX_B.Init_f = L4_MABX_B.Xold_j;

  }



  /* End of Switch: '<S794>/Init' */



  /* Sum: '<S790>/FixPt Sum1' incorporates:

   *  Constant: '<S790>/FixPt Constant'

   */

  L4_MABX_B.FixPtSum1_n = L4_MABX_B.Init_f - L4_MABX_P.FixPtConstant_Value_j;



  /* Sum: '<S793>/FixPt Sum1' incorporates:

   *  Constant: '<S793>/FixPt Constant'

   */

  L4_MABX_B.FixPtSum1_o = L4_MABX_B.Init_f + L4_MABX_P.FixPtConstant_Value_oo;



  /* Outputs for Atomic SubSystem: '<S784>/If_Then_Else3' */

  L4_MABX_If_Then_Else(L4_MABX_B.conjunction_p, L4_MABX_B.FixPtSum1_n,

                       L4_MABX_B.FixPtSum1_o, &L4_MABX_B.If_Then_Else3);



  /* End of Outputs for SubSystem: '<S784>/If_Then_Else3' */



  /* RelationalOperator: '<S791>/Relational Operator1' incorporates:

   *  Constant: '<S769>/PWMADCRngFaultLimMax'

   */

  L4_MABX_B.RelationalOperator1_l = (L4_MABX_B.If_Then_Else3.Switch >=

    L4_MABX_P.PWMADCRngFaultLimMax_Value);



  /* RelationalOperator: '<S791>/Relational Operator' incorporates:

   *  Constant: '<S769>/PWMADCRngFaultLimMin'

   */

  L4_MABX_B.RelationalOperator_m = (L4_MABX_B.If_Then_Else3.Switch <=

    L4_MABX_P.PWMADCRngFaultLimMin_Value);



  /* Outputs for Atomic SubSystem: '<S791>/If_Then_Else1' */



  /* Constant: '<S769>/PWMADCRngFaultLimMin' */

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator_m,

                       L4_MABX_P.PWMADCRngFaultLimMin_Value,

                       L4_MABX_B.If_Then_Else3.Switch,

                       &L4_MABX_B.If_Then_Else1_p);



  /* End of Outputs for SubSystem: '<S791>/If_Then_Else1' */



  /* Outputs for Atomic SubSystem: '<S791>/If_Then_Else' */



  /* Constant: '<S769>/PWMADCRngFaultLimMax' */

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator1_l,

                       L4_MABX_P.PWMADCRngFaultLimMax_Value,

                       L4_MABX_B.If_Then_Else1_p.Switch,

                       &L4_MABX_B.If_Then_Else_h);



  /* End of Outputs for SubSystem: '<S791>/If_Then_Else' */



  /* RelationalOperator: '<S784>/Relational Operator9' incorporates:

   *  Constant: '<S769>/PWMADCRngFaultLimMin'

   */

  L4_MABX_B.F_Fault_Soft_c = (L4_MABX_B.If_Then_Else_h.Switch !=

    L4_MABX_P.PWMADCRngFaultLimMin_Value);



  /* Logic: '<S769>/Logical Operator2' */

  L4_MABX_B.LogicalOperator2 = (L4_MABX_B.F_Fault_Soft ||

    L4_MABX_B.F_Fault_Soft_c);



  /* RelationalOperator: '<S785>/Relational Operator8' incorporates:

   *  Constant: '<S769>/PWMAFreqRngFaultLimMax'

   */

  L4_MABX_B.F_Fault_Hard = (L4_MABX_P.PWMAFreqRngFaultLimMax_Value <=

    L4_MABX_B.If_Then_Else_a.Switch);



  /* RelationalOperator: '<S784>/Relational Operator8' incorporates:

   *  Constant: '<S769>/PWMADCRngFaultLimMax'

   */

  L4_MABX_B.F_Fault_Hard_c = (L4_MABX_P.PWMADCRngFaultLimMax_Value <=

    L4_MABX_B.If_Then_Else_h.Switch);



  /* Logic: '<S769>/Logical Operator1' */

  L4_MABX_B.LogicalOperator1 = (L4_MABX_B.F_Fault_Hard ||

    L4_MABX_B.F_Fault_Hard_c);



  /* Chart: '<S769>/Health State Machine PWM Sensor 1' */

  /* Gateway: DIGITAL/PWM pedal input management/Diagnose pedal input signals/Health State Machine PWM Sensor 1 */

  /* During: DIGITAL/PWM pedal input management/Diagnose pedal input signals/Health State Machine PWM Sensor 1 */

  if (L4_MABX_DW.is_active_c9_SUB_ECU_L4_MABX_HW == 0U) {

    /* Entry: DIGITAL/PWM pedal input management/Diagnose pedal input signals/Health State Machine PWM Sensor 1 */

    L4_MABX_DW.is_active_c9_SUB_ECU_L4_MABX_HW = 1U;



    /* Entry Internal: DIGITAL/PWM pedal input management/Diagnose pedal input signals/Health State Machine PWM Sensor 1 */

    /* Transition: '<S782>:2' */

    L4_MABX_DW.is_c9_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_NO_FAILURE;



    /* Entry 'NO_FAILURE': '<S782>:1' */

    L4_MABX_B.Pedal_1_pwm_health_state = ENUM_SIGNAL_HEALTH_T_FAULT_INACTIVE;

  } else if (L4_MABX_DW.is_c9_SUB_ECU_L4_MABX_HW_Interf ==

             L4_MABX_IN_FAILURE_DETECTED) {

    /* During 'FAILURE_DETECTED': '<S782>:6' */

    if (L4_MABX_DW.is_FAILURE_DETECTED_b == L4_MABX_IN_ERROR) {

      L4_MABX_B.Pedal_1_pwm_health_state = ENUM_SIGNAL_HEALTH_T_FAULT_ACTIVE;



      /* During 'ERROR': '<S782>:8' */

      if (!L4_MABX_B.LogicalOperator1) {

        /* Transition: '<S782>:17' */

        L4_MABX_DW.is_FAILURE_DETECTED_b = L4_MABX_IN_PENDING;



        /* Entry 'PENDING': '<S782>:7' */

        L4_MABX_B.Pedal_1_pwm_health_state = ENUM_SIGNAL_HEALTH_T_FAULT_PENDING;

      }

    } else {

      L4_MABX_B.Pedal_1_pwm_health_state = ENUM_SIGNAL_HEALTH_T_FAULT_PENDING;



      /* During 'PENDING': '<S782>:7' */

      zcEvent = ((!L4_MABX_B.LogicalOperator2) && (!L4_MABX_B.LogicalOperator1));

      if (zcEvent) {

        /* Transition: '<S782>:9' */

        L4_MABX_DW.is_FAILURE_DETECTED_b = L4_MABX_IN_NO_ACTIVE_CHILD;

        L4_MABX_DW.is_c9_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_NO_FAILURE;



        /* Entry 'NO_FAILURE': '<S782>:1' */

        L4_MABX_B.Pedal_1_pwm_health_state = ENUM_SIGNAL_HEALTH_T_FAULT_INACTIVE;

      } else {

        if (L4_MABX_B.LogicalOperator1) {

          /* Transition: '<S782>:12' */

          L4_MABX_DW.is_FAILURE_DETECTED_b = L4_MABX_IN_ERROR;



          /* Entry 'ERROR': '<S782>:8' */

          L4_MABX_B.Pedal_1_pwm_health_state = ENUM_SIGNAL_HEALTH_T_FAULT_ACTIVE;

        }

      }

    }

  } else {

    L4_MABX_B.Pedal_1_pwm_health_state = ENUM_SIGNAL_HEALTH_T_FAULT_INACTIVE;



    /* During 'NO_FAILURE': '<S782>:1' */

    zcEvent = (L4_MABX_B.LogicalOperator2 || L4_MABX_B.LogicalOperator1);

    if (zcEvent) {

      /* Transition: '<S782>:10' */

      L4_MABX_DW.is_c9_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_FAILURE_DETECTED;



      /* Entry 'FAILURE_DETECTED': '<S782>:6' */

      /* Entry Internal 'FAILURE_DETECTED': '<S782>:6' */

      /* Transition: '<S782>:11' */

      L4_MABX_DW.is_FAILURE_DETECTED_b = L4_MABX_IN_PENDING;



      /* Entry 'PENDING': '<S782>:7' */

      L4_MABX_B.Pedal_1_pwm_health_state = ENUM_SIGNAL_HEALTH_T_FAULT_PENDING;

    }

  }



  /* End of Chart: '<S769>/Health State Machine PWM Sensor 1' */



  /* RelationalOperator: '<S780>/Compare' incorporates:

   *  Constant: '<S780>/Constant'

   */

  L4_MABX_B.Compare_n = (L4_MABX_B.Pedal_1_pwm_health_state ==

    L4_MABX_P.CompareToConstant_const_g2);



  /* S-Function (rti_commonblock): '<S747>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* DataTypeConversion: '<S422>/Data Type Conversion3' */

  L4_MABX_B.Pedal_2_pwm_freq_raw_value = L4_MABX_B.SFunction1_o1_k;



  /* RelationalOperator: '<S813>/min_relop' incorporates:

   *  Constant: '<S769>/PWMBFreqRngMin1'

   */

  L4_MABX_B.min_relop_a = (L4_MABX_P.PWMBFreqRngMin1_Value <

    L4_MABX_B.Pedal_2_pwm_freq_raw_value);



  /* RelationalOperator: '<S813>/max_relop' incorporates:

   *  Constant: '<S769>/PWMBFreqRngMax1'

   */

  L4_MABX_B.max_relop_j = (L4_MABX_B.Pedal_2_pwm_freq_raw_value <

    L4_MABX_P.PWMBFreqRngMax1_Value);



  /* Logic: '<S813>/conjunction' */

  L4_MABX_B.conjunction_f = (L4_MABX_B.min_relop_a && L4_MABX_B.max_relop_j);



  /* UnitDelay: '<S818>/FixPt Unit Delay2' */

  L4_MABX_B.FixPtUnitDelay2_c = L4_MABX_DW.FixPtUnitDelay2_DSTATE_a;



  /* UnitDelay: '<S818>/FixPt Unit Delay1' */

  L4_MABX_B.Xold_e = L4_MABX_DW.FixPtUnitDelay1_DSTATE_g;



  /* Switch: '<S818>/Init' incorporates:

   *  Constant: '<S769>/PWMBFreqRngFaultLimMin1'

   */

  if (L4_MABX_B.FixPtUnitDelay2_c != 0) {

    L4_MABX_B.Init_i = L4_MABX_P.PWMBFreqRngFaultLimMin1_Value;

  } else {

    L4_MABX_B.Init_i = L4_MABX_B.Xold_e;

  }



  /* End of Switch: '<S818>/Init' */



  /* Sum: '<S814>/FixPt Sum1' incorporates:

   *  Constant: '<S814>/FixPt Constant'

   */

  L4_MABX_B.FixPtSum1_a = L4_MABX_B.Init_i - L4_MABX_P.FixPtConstant_Value_a;



  /* Sum: '<S817>/FixPt Sum1' incorporates:

   *  Constant: '<S817>/FixPt Constant'

   */

  L4_MABX_B.FixPtSum1_me = L4_MABX_B.Init_i + L4_MABX_P.FixPtConstant_Value_n;



  /* Outputs for Atomic SubSystem: '<S787>/If_Then_Else3' */

  L4_MABX_If_Then_Else(L4_MABX_B.conjunction_f, L4_MABX_B.FixPtSum1_a,

                       L4_MABX_B.FixPtSum1_me, &L4_MABX_B.If_Then_Else3_f);



  /* End of Outputs for SubSystem: '<S787>/If_Then_Else3' */



  /* RelationalOperator: '<S815>/Relational Operator1' incorporates:

   *  Constant: '<S769>/PWMBFreqRngFaultLimMax1'

   */

  L4_MABX_B.RelationalOperator1_c = (L4_MABX_B.If_Then_Else3_f.Switch >=

    L4_MABX_P.PWMBFreqRngFaultLimMax1_Value);



  /* RelationalOperator: '<S815>/Relational Operator' incorporates:

   *  Constant: '<S769>/PWMBFreqRngFaultLimMin1'

   */

  L4_MABX_B.RelationalOperator_c = (L4_MABX_B.If_Then_Else3_f.Switch <=

    L4_MABX_P.PWMBFreqRngFaultLimMin1_Value);



  /* Outputs for Atomic SubSystem: '<S815>/If_Then_Else1' */



  /* Constant: '<S769>/PWMBFreqRngFaultLimMin1' */

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator_c,

                       L4_MABX_P.PWMBFreqRngFaultLimMin1_Value,

                       L4_MABX_B.If_Then_Else3_f.Switch,

                       &L4_MABX_B.If_Then_Else1_br);



  /* End of Outputs for SubSystem: '<S815>/If_Then_Else1' */



  /* Outputs for Atomic SubSystem: '<S815>/If_Then_Else' */



  /* Constant: '<S769>/PWMBFreqRngFaultLimMax1' */

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator1_c,

                       L4_MABX_P.PWMBFreqRngFaultLimMax1_Value,

                       L4_MABX_B.If_Then_Else1_br.Switch,

                       &L4_MABX_B.If_Then_Else_p);



  /* End of Outputs for SubSystem: '<S815>/If_Then_Else' */



  /* RelationalOperator: '<S787>/Relational Operator9' incorporates:

   *  Constant: '<S769>/PWMBFreqRngFaultLimMin1'

   */

  L4_MABX_B.F_Fault_Soft_i = (L4_MABX_B.If_Then_Else_p.Switch !=

    L4_MABX_P.PWMBFreqRngFaultLimMin1_Value);



  /* Gain: '<S422>/Gain1' */

  L4_MABX_B.Gain1 = L4_MABX_P.Gain1_Gain_ps * L4_MABX_B.SFunction1_o2_m;



  /* DataTypeConversion: '<S422>/Data Type Conversion1' */

  L4_MABX_B.Pedal_2_pwm_dc_raw_value = L4_MABX_B.Gain1;



  /* RelationalOperator: '<S805>/min_relop' incorporates:

   *  Constant: '<S769>/PWMBDCRngMin1'

   */

  L4_MABX_B.min_relop_o = (L4_MABX_P.PWMBDCRngMin1_Value <

    L4_MABX_B.Pedal_2_pwm_dc_raw_value);



  /* RelationalOperator: '<S805>/max_relop' incorporates:

   *  Constant: '<S769>/PWMBDCRngMax1'

   */

  L4_MABX_B.max_relop_m = (L4_MABX_B.Pedal_2_pwm_dc_raw_value <

    L4_MABX_P.PWMBDCRngMax1_Value);



  /* Logic: '<S805>/conjunction' */

  L4_MABX_B.conjunction_d = (L4_MABX_B.min_relop_o && L4_MABX_B.max_relop_m);



  /* UnitDelay: '<S810>/FixPt Unit Delay2' */

  L4_MABX_B.FixPtUnitDelay2_i = L4_MABX_DW.FixPtUnitDelay2_DSTATE_i;



  /* UnitDelay: '<S810>/FixPt Unit Delay1' */

  L4_MABX_B.Xold_p = L4_MABX_DW.FixPtUnitDelay1_DSTATE_e;



  /* Switch: '<S810>/Init' incorporates:

   *  Constant: '<S769>/PWMBDCRngFaultLimMin1'

   */

  if (L4_MABX_B.FixPtUnitDelay2_i != 0) {

    L4_MABX_B.Init_j = L4_MABX_P.PWMBDCRngFaultLimMin1_Value;

  } else {

    L4_MABX_B.Init_j = L4_MABX_B.Xold_p;

  }



  /* End of Switch: '<S810>/Init' */



  /* Sum: '<S806>/FixPt Sum1' incorporates:

   *  Constant: '<S806>/FixPt Constant'

   */

  L4_MABX_B.FixPtSum1_p = L4_MABX_B.Init_j - L4_MABX_P.FixPtConstant_Value_k;



  /* Sum: '<S809>/FixPt Sum1' incorporates:

   *  Constant: '<S809>/FixPt Constant'

   */

  L4_MABX_B.FixPtSum1_h = L4_MABX_B.Init_j + L4_MABX_P.FixPtConstant_Value_oj;



  /* Outputs for Atomic SubSystem: '<S786>/If_Then_Else3' */

  L4_MABX_If_Then_Else(L4_MABX_B.conjunction_d, L4_MABX_B.FixPtSum1_p,

                       L4_MABX_B.FixPtSum1_h, &L4_MABX_B.If_Then_Else3_de);



  /* End of Outputs for SubSystem: '<S786>/If_Then_Else3' */



  /* RelationalOperator: '<S807>/Relational Operator1' incorporates:

   *  Constant: '<S769>/PWMBDCRngFaultLimMax1'

   */

  L4_MABX_B.RelationalOperator1_p = (L4_MABX_B.If_Then_Else3_de.Switch >=

    L4_MABX_P.PWMBDCRngFaultLimMax1_Value);



  /* RelationalOperator: '<S807>/Relational Operator' incorporates:

   *  Constant: '<S769>/PWMBDCRngFaultLimMin1'

   */

  L4_MABX_B.RelationalOperator_l = (L4_MABX_B.If_Then_Else3_de.Switch <=

    L4_MABX_P.PWMBDCRngFaultLimMin1_Value);



  /* Outputs for Atomic SubSystem: '<S807>/If_Then_Else1' */



  /* Constant: '<S769>/PWMBDCRngFaultLimMin1' */

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator_l,

                       L4_MABX_P.PWMBDCRngFaultLimMin1_Value,

                       L4_MABX_B.If_Then_Else3_de.Switch,

                       &L4_MABX_B.If_Then_Else1_g);



  /* End of Outputs for SubSystem: '<S807>/If_Then_Else1' */



  /* Outputs for Atomic SubSystem: '<S807>/If_Then_Else' */



  /* Constant: '<S769>/PWMBDCRngFaultLimMax1' */

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator1_p,

                       L4_MABX_P.PWMBDCRngFaultLimMax1_Value,

                       L4_MABX_B.If_Then_Else1_g.Switch,

                       &L4_MABX_B.If_Then_Else_k);



  /* End of Outputs for SubSystem: '<S807>/If_Then_Else' */



  /* RelationalOperator: '<S786>/Relational Operator9' incorporates:

   *  Constant: '<S769>/PWMBDCRngFaultLimMin1'

   */

  L4_MABX_B.F_Fault_Soft_e = (L4_MABX_B.If_Then_Else_k.Switch !=

    L4_MABX_P.PWMBDCRngFaultLimMin1_Value);



  /* Logic: '<S769>/Logical Operator4' */

  L4_MABX_B.LogicalOperator4 = (L4_MABX_B.F_Fault_Soft_i ||

    L4_MABX_B.F_Fault_Soft_e);



  /* RelationalOperator: '<S787>/Relational Operator8' incorporates:

   *  Constant: '<S769>/PWMBFreqRngFaultLimMax1'

   */

  L4_MABX_B.F_Fault_Hard_h = (L4_MABX_P.PWMBFreqRngFaultLimMax1_Value <=

    L4_MABX_B.If_Then_Else_p.Switch);



  /* RelationalOperator: '<S786>/Relational Operator8' incorporates:

   *  Constant: '<S769>/PWMBDCRngFaultLimMax1'

   */

  L4_MABX_B.F_Fault_Hard_p = (L4_MABX_P.PWMBDCRngFaultLimMax1_Value <=

    L4_MABX_B.If_Then_Else_k.Switch);



  /* Logic: '<S769>/Logical Operator3' */

  L4_MABX_B.LogicalOperator3 = (L4_MABX_B.F_Fault_Hard_h ||

    L4_MABX_B.F_Fault_Hard_p);



  /* Chart: '<S769>/Health State Machine PWM Sensor 2' */

  /* Gateway: DIGITAL/PWM pedal input management/Diagnose pedal input signals/Health State Machine PWM Sensor 2 */

  /* During: DIGITAL/PWM pedal input management/Diagnose pedal input signals/Health State Machine PWM Sensor 2 */

  if (L4_MABX_DW.is_active_c10_SUB_ECU_L4_MABX_H == 0U) {

    /* Entry: DIGITAL/PWM pedal input management/Diagnose pedal input signals/Health State Machine PWM Sensor 2 */

    L4_MABX_DW.is_active_c10_SUB_ECU_L4_MABX_H = 1U;



    /* Entry Internal: DIGITAL/PWM pedal input management/Diagnose pedal input signals/Health State Machine PWM Sensor 2 */

    /* Transition: '<S783>:2' */

    L4_MABX_DW.is_c10_SUB_ECU_L4_MABX_HW_Inter = L4_MABX_IN_NO_FAILURE;



    /* Entry 'NO_FAILURE': '<S783>:1' */

    L4_MABX_B.Pedal_2_pwm_health_state = ENUM_SIGNAL_HEALTH_T_FAULT_INACTIVE;

  } else if (L4_MABX_DW.is_c10_SUB_ECU_L4_MABX_HW_Inter ==

             L4_MABX_IN_FAILURE_DETECTED) {

    /* During 'FAILURE_DETECTED': '<S783>:6' */

    if (L4_MABX_DW.is_FAILURE_DETECTED == L4_MABX_IN_ERROR) {

      L4_MABX_B.Pedal_2_pwm_health_state = ENUM_SIGNAL_HEALTH_T_FAULT_ACTIVE;



      /* During 'ERROR': '<S783>:8' */

      if (!L4_MABX_B.LogicalOperator3) {

        /* Transition: '<S783>:20' */

        L4_MABX_DW.is_FAILURE_DETECTED = L4_MABX_IN_PENDING;



        /* Entry 'PENDING': '<S783>:7' */

        L4_MABX_B.Pedal_2_pwm_health_state = ENUM_SIGNAL_HEALTH_T_FAULT_PENDING;

      }

    } else {

      L4_MABX_B.Pedal_2_pwm_health_state = ENUM_SIGNAL_HEALTH_T_FAULT_PENDING;



      /* During 'PENDING': '<S783>:7' */

      zcEvent = ((!L4_MABX_B.LogicalOperator4) && (!L4_MABX_B.LogicalOperator3));

      if (zcEvent) {

        /* Transition: '<S783>:9' */

        L4_MABX_DW.is_FAILURE_DETECTED = L4_MABX_IN_NO_ACTIVE_CHILD;

        L4_MABX_DW.is_c10_SUB_ECU_L4_MABX_HW_Inter = L4_MABX_IN_NO_FAILURE;



        /* Entry 'NO_FAILURE': '<S783>:1' */

        L4_MABX_B.Pedal_2_pwm_health_state = ENUM_SIGNAL_HEALTH_T_FAULT_INACTIVE;

      } else {

        if (L4_MABX_B.LogicalOperator3) {

          /* Transition: '<S783>:12' */

          L4_MABX_DW.is_FAILURE_DETECTED = L4_MABX_IN_ERROR;



          /* Entry 'ERROR': '<S783>:8' */

          L4_MABX_B.Pedal_2_pwm_health_state = ENUM_SIGNAL_HEALTH_T_FAULT_ACTIVE;

        }

      }

    }

  } else {

    L4_MABX_B.Pedal_2_pwm_health_state = ENUM_SIGNAL_HEALTH_T_FAULT_INACTIVE;



    /* During 'NO_FAILURE': '<S783>:1' */

    zcEvent = (L4_MABX_B.LogicalOperator4 || L4_MABX_B.LogicalOperator3);

    if (zcEvent) {

      /* Transition: '<S783>:10' */

      L4_MABX_DW.is_c10_SUB_ECU_L4_MABX_HW_Inter = L4_MABX_IN_FAILURE_DETECTED;



      /* Entry 'FAILURE_DETECTED': '<S783>:6' */

      /* Entry Internal 'FAILURE_DETECTED': '<S783>:6' */

      /* Transition: '<S783>:11' */

      L4_MABX_DW.is_FAILURE_DETECTED = L4_MABX_IN_PENDING;



      /* Entry 'PENDING': '<S783>:7' */

      L4_MABX_B.Pedal_2_pwm_health_state = ENUM_SIGNAL_HEALTH_T_FAULT_PENDING;

    }

  }



  /* End of Chart: '<S769>/Health State Machine PWM Sensor 2' */



  /* RelationalOperator: '<S781>/Compare' incorporates:

   *  Constant: '<S781>/Constant'

   */

  L4_MABX_B.Compare_a = (L4_MABX_B.Pedal_2_pwm_health_state ==

    L4_MABX_P.CompareToConstant2_const_d);



  /* Logic: '<S769>/Logical Operator5' */

  L4_MABX_B.F_Pedal_pwm_sens_total_failure = (L4_MABX_B.Compare_n &&

    L4_MABX_B.Compare_a);



  /* UnitDelay: '<S772>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_bl = L4_MABX_DW.Unit_Delay_DSTATE_pw;



  /* UnitDelay: '<S839>/Unit_Delay1' */

  L4_MABX_B.Unit_Delay1 = L4_MABX_DW.Unit_Delay1_DSTATE;



  /* Logic: '<S839>/Logical Operator' */

  L4_MABX_B.LogicalOperator_i = (L4_MABX_B.Unit_Delay_bl ||

    L4_MABX_B.Unit_Delay1);



  /* MinMax: '<S839>/MinMax1' incorporates:

   *  Constant: '<S772>/PEDAL_PWM_SENSOR_DATA_APV.T1_CONST'

   *  Constant: '<S772>/dT'

   */

  DeltaTime = L4_MABX_P.dT_Value;

  PositionFinalLimited = L4_MABX_P.PEDAL_PWM_SENSOR_DATA_APVT1_CON;

  if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax1 = PositionFinalLimited;



  /* End of MinMax: '<S839>/MinMax1' */



  /* Saturate: '<S839>/Saturation' */

  DeltaTime = L4_MABX_B.MinMax1;

  Time56 = L4_MABX_P.Saturation_LowerSat_f;

  AccelerationAverage = L4_MABX_P.Saturation_UpperSat_ld;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Saturation = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Saturation = Time56;

  } else {

    L4_MABX_B.Saturation = DeltaTime;

  }



  /* End of Saturate: '<S839>/Saturation' */



  /* Product: '<S839>/Divide' incorporates:

   *  Constant: '<S772>/dT'

   */

  L4_MABX_B.Divide = L4_MABX_P.dT_Value / L4_MABX_B.Saturation;



  /* Product: '<S839>/Product2' */

  L4_MABX_B.Product2 = L4_MABX_B.Pedal_1_pwm_dc_raw_value * L4_MABX_B.Divide;



  /* Sum: '<S839>/Subtract1' incorporates:

   *  Constant: '<S839>/Constant1'

   */

  L4_MABX_B.Subtract1 = L4_MABX_P.Constant1_Value_cw - L4_MABX_B.Divide;



  /* UnitDelay: '<S839>/Unit_Delay2' */

  L4_MABX_B.Unit_Delay2 = L4_MABX_DW.Unit_Delay2_DSTATE;



  /* Product: '<S839>/Product1' */

  L4_MABX_B.Product1 = L4_MABX_B.Subtract1 * L4_MABX_B.Unit_Delay2;



  /* Sum: '<S839>/Add1' */

  L4_MABX_B.Add1 = L4_MABX_B.Product2 + L4_MABX_B.Product1;



  /* Outputs for Atomic SubSystem: '<S839>/If_Then_Else' */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator_i,

                       L4_MABX_B.Pedal_1_pwm_dc_raw_value, L4_MABX_B.Add1,

                       &L4_MABX_B.If_Then_Else_i);



  /* End of Outputs for SubSystem: '<S839>/If_Then_Else' */



  /* Lookup_n-D: '<S772>/PEDAL_PWM_ANGLE_SENS_1_MPV' */

  L4_MABX_B.Pedal_1_pwm_undefault = look1_binlcapw

    (L4_MABX_B.If_Then_Else_i.Switch, L4_MABX_P.PEDAL_PWM_ANGLE_SENS_1_MPV_bp01,

     L4_MABX_P.PEDAL_PWM_ANGLE_SENS_1_MPV_tabl, 7U);



  /* UnitDelay: '<S772>/Unit_Delay1' */

  L4_MABX_B.Unit_Delay1_a = L4_MABX_DW.Unit_Delay1_DSTATE_m;



  /* UnitDelay: '<S840>/Unit_Delay1' */

  L4_MABX_B.Unit_Delay1_d = L4_MABX_DW.Unit_Delay1_DSTATE_p;



  /* Logic: '<S840>/Logical Operator' */

  L4_MABX_B.LogicalOperator_p = (L4_MABX_B.Unit_Delay1_a ||

    L4_MABX_B.Unit_Delay1_d);



  /* MinMax: '<S840>/MinMax1' incorporates:

   *  Constant: '<S772>/PEDAL_PWM_SENSOR_DATA_APV.T2_CONST'

   *  Constant: '<S772>/dT1'

   */

  DeltaTime = L4_MABX_P.dT1_Value;

  PositionFinalLimited = L4_MABX_P.PEDAL_PWM_SENSOR_DATA_APVT2_CON;

  if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax1_a = PositionFinalLimited;



  /* End of MinMax: '<S840>/MinMax1' */



  /* Saturate: '<S840>/Saturation' */

  DeltaTime = L4_MABX_B.MinMax1_a;

  Time56 = L4_MABX_P.Saturation_LowerSat_bz;

  AccelerationAverage = L4_MABX_P.Saturation_UpperSat_b;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Saturation_l = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Saturation_l = Time56;

  } else {

    L4_MABX_B.Saturation_l = DeltaTime;

  }



  /* End of Saturate: '<S840>/Saturation' */



  /* Product: '<S840>/Divide' incorporates:

   *  Constant: '<S772>/dT1'

   */

  L4_MABX_B.Divide_c = L4_MABX_P.dT1_Value / L4_MABX_B.Saturation_l;



  /* Product: '<S840>/Product2' */

  L4_MABX_B.Product2_e = L4_MABX_B.Pedal_2_pwm_freq_raw_value *

    L4_MABX_B.Divide_c;



  /* Sum: '<S840>/Subtract1' incorporates:

   *  Constant: '<S840>/Constant1'

   */

  L4_MABX_B.Subtract1_f = L4_MABX_P.Constant1_Value_cju - L4_MABX_B.Divide_c;



  /* UnitDelay: '<S840>/Unit_Delay2' */

  L4_MABX_B.Unit_Delay2_f = L4_MABX_DW.Unit_Delay2_DSTATE_g;



  /* Product: '<S840>/Product1' */

  L4_MABX_B.Product1_e = L4_MABX_B.Subtract1_f * L4_MABX_B.Unit_Delay2_f;



  /* Sum: '<S840>/Add1' */

  L4_MABX_B.Add1_p = L4_MABX_B.Product2_e + L4_MABX_B.Product1_e;



  /* Outputs for Atomic SubSystem: '<S840>/If_Then_Else' */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator_p,

                       L4_MABX_B.Pedal_2_pwm_freq_raw_value, L4_MABX_B.Add1_p,

                       &L4_MABX_B.If_Then_Else_b);



  /* End of Outputs for SubSystem: '<S840>/If_Then_Else' */



  /* Lookup_n-D: '<S772>/PEDAL_PWM_ANGLE_SENS_2_MPV' */

  L4_MABX_B.Pedal_2_pwm_undefault = look1_binlcapw

    (L4_MABX_B.If_Then_Else_b.Switch, L4_MABX_P.PEDAL_PWM_ANGLE_SENS_2_MPV_bp01,

     L4_MABX_P.PEDAL_PWM_ANGLE_SENS_2_MPV_tabl, 7U);



  /* Sum: '<S774>/Subtract' */

  L4_MABX_B.Subtract = L4_MABX_B.Pedal_1_pwm_undefault -

    L4_MABX_B.Pedal_2_pwm_undefault;



  /* Abs: '<S774>/Abs' */

  L4_MABX_B.Abs = fabs(L4_MABX_B.Subtract);



  /* RelationalOperator: '<S776>/Compare' incorporates:

   *  Constant: '<S776>/Constant'

   */

  L4_MABX_B.Compare_f = (L4_MABX_B.Pedal_1_pwm_health_state ==

    L4_MABX_P.CompareToConstant3_const_i);



  /* RelationalOperator: '<S832>/Compare' incorporates:

   *  Constant: '<S832>/Constant'

   */

  L4_MABX_B.Compare_ns = (L4_MABX_B.Pedal_2_pwm_health_state ==

    L4_MABX_P.CompareToConstant5_const);



  /* Logic: '<S770>/Logical Operator7' */

  L4_MABX_B.LogicalOperator7 = !L4_MABX_B.Compare_ns;



  /* RelationalOperator: '<S831>/Compare' incorporates:

   *  Constant: '<S831>/Constant'

   */

  L4_MABX_B.Compare_o = (L4_MABX_B.Pedal_2_pwm_health_state ==

    L4_MABX_P.CompareToConstant4_const);



  /* Logic: '<S770>/Logical Operator8' */

  L4_MABX_B.LogicalOperator8 = !L4_MABX_B.Compare_o;



  /* UnitDelay: '<S838>/FixPt Unit Delay2' */

  L4_MABX_B.FixPtUnitDelay2_h = L4_MABX_DW.FixPtUnitDelay2_DSTATE_d1;



  /* UnitDelay: '<S838>/FixPt Unit Delay1' */

  L4_MABX_B.Xold_pw = L4_MABX_DW.FixPtUnitDelay1_DSTATE_n;



  /* Switch: '<S838>/Init' incorporates:

   *  Constant: '<S750>/PEDAL_PWM_SENSOR_DATA_APV.DEFAULT_VALUE'

   */

  if (L4_MABX_B.FixPtUnitDelay2_h != 0) {

    L4_MABX_B.Init_g = L4_MABX_P.PEDAL_PWM_SENSOR_DATA_APVDEFAUL;

  } else {

    L4_MABX_B.Init_g = L4_MABX_B.Xold_pw;

  }



  /* End of Switch: '<S838>/Init' */



  /* Outputs for Atomic SubSystem: '<S770>/If_Then_Else3' */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator8,

                       L4_MABX_B.Pedal_2_pwm_undefault, L4_MABX_B.Init_g,

                       &L4_MABX_B.If_Then_Else3_c);



  /* End of Outputs for SubSystem: '<S770>/If_Then_Else3' */



  /* Outputs for Atomic SubSystem: '<S770>/If_Then_Else2' */



  /* Constant: '<S750>/PEDAL_PWM_SENSOR_DATA_APV.DEFAULT_VALUE' */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator7,

                       L4_MABX_B.If_Then_Else3_c.Switch,

                       L4_MABX_P.PEDAL_PWM_SENSOR_DATA_APVDEFAUL,

                       &L4_MABX_B.If_Then_Else2_k);



  /* End of Outputs for SubSystem: '<S770>/If_Then_Else2' */



  /* RelationalOperator: '<S830>/Compare' incorporates:

   *  Constant: '<S830>/Constant'

   */

  L4_MABX_B.Compare_h = (L4_MABX_B.Pedal_1_pwm_health_state ==

    L4_MABX_P.CompareToConstant3_const_d);



  /* Logic: '<S770>/Logical Operator5' */

  L4_MABX_B.LogicalOperator5 = !L4_MABX_B.Compare_h;



  /* RelationalOperator: '<S829>/Compare' incorporates:

   *  Constant: '<S829>/Constant'

   */

  L4_MABX_B.Compare_m = (L4_MABX_B.Pedal_1_pwm_health_state ==

    L4_MABX_P.CompareToConstant1_const_j2);



  /* Logic: '<S770>/Logical Operator6' */

  L4_MABX_B.LogicalOperator6 = !L4_MABX_B.Compare_m;



  /* UnitDelay: '<S837>/FixPt Unit Delay2' */

  L4_MABX_B.FixPtUnitDelay2_iq = L4_MABX_DW.FixPtUnitDelay2_DSTATE_g;



  /* UnitDelay: '<S837>/FixPt Unit Delay1' */

  L4_MABX_B.Xold_n = L4_MABX_DW.FixPtUnitDelay1_DSTATE_j;



  /* Switch: '<S837>/Init' incorporates:

   *  Constant: '<S750>/PEDAL_PWM_SENSOR_DATA_APV.DEFAULT_VALUE'

   */

  if (L4_MABX_B.FixPtUnitDelay2_iq != 0) {

    L4_MABX_B.Init_p = L4_MABX_P.PEDAL_PWM_SENSOR_DATA_APVDEFAUL;

  } else {

    L4_MABX_B.Init_p = L4_MABX_B.Xold_n;

  }



  /* End of Switch: '<S837>/Init' */



  /* Outputs for Atomic SubSystem: '<S770>/If_Then_Else1' */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator6,

                       L4_MABX_B.Pedal_1_pwm_undefault, L4_MABX_B.Init_p,

                       &L4_MABX_B.If_Then_Else1_c);



  /* End of Outputs for SubSystem: '<S770>/If_Then_Else1' */



  /* Outputs for Atomic SubSystem: '<S770>/If_Then_Else' */



  /* Constant: '<S750>/PEDAL_PWM_SENSOR_DATA_APV.DEFAULT_VALUE' */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator5,

                       L4_MABX_B.If_Then_Else1_c.Switch,

                       L4_MABX_P.PEDAL_PWM_SENSOR_DATA_APVDEFAUL,

                       &L4_MABX_B.If_Then_Else_l);



  /* End of Outputs for SubSystem: '<S770>/If_Then_Else' */



  /* Outputs for Atomic SubSystem: '<S768>/If_Then_Else1' */

  L4_MABX_If_Then_Else(L4_MABX_B.Compare_f, L4_MABX_B.If_Then_Else2_k.Switch,

                       L4_MABX_B.If_Then_Else_l.Switch, &L4_MABX_B.If_Then_Else1);



  /* End of Outputs for SubSystem: '<S768>/If_Then_Else1' */



  /* RelationalOperator: '<S775>/Compare' incorporates:

   *  Constant: '<S775>/Constant'

   */

  L4_MABX_B.Compare_hn = (L4_MABX_B.Pedal_2_pwm_health_state ==

    L4_MABX_P.CompareToConstant1_const_k);



  /* Outputs for Atomic SubSystem: '<S768>/If_Then_Else2' */

  L4_MABX_If_Then_Else(L4_MABX_B.Compare_hn, L4_MABX_B.If_Then_Else_l.Switch,

                       L4_MABX_B.If_Then_Else2_k.Switch,

                       &L4_MABX_B.If_Then_Else2);



  /* End of Outputs for SubSystem: '<S768>/If_Then_Else2' */



  /* MinMax: '<S768>/MinMax' */

  DeltaTime = L4_MABX_B.If_Then_Else1.Switch;

  PositionFinalLimited = L4_MABX_B.If_Then_Else2.Switch;

  if ((DeltaTime < PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax = PositionFinalLimited;



  /* End of MinMax: '<S768>/MinMax' */



  /* Outputs for Atomic SubSystem: '<S768>/If_Then_Else' */



  /* Constant: '<S750>/PEDAL_PWM_SENSOR_DATA_APV.DEFAULT_VALUE' */

  L4_MABX_If_Then_Else(L4_MABX_B.F_Pedal_pwm_sens_total_failure,

                       L4_MABX_P.PEDAL_PWM_SENSOR_DATA_APVDEFAUL,

                       L4_MABX_B.MinMax, &L4_MABX_B.If_Then_Else_o);



  /* End of Outputs for SubSystem: '<S768>/If_Then_Else' */



  /* Lookup_n-D: '<S774>/PEDAL_PWM_ANGLE_DEV_MPV' */

  L4_MABX_B.PEDAL_PWM_ANGLE_DEV_MPV = look1_binlcapw

    (L4_MABX_B.If_Then_Else_o.Switch, L4_MABX_P.PEDAL_PWM_ANGLE_DEV_MPV_bp01Dat,

     L4_MABX_P.PEDAL_PWM_ANGLE_DEV_MPV_tableDa, 7U);



  /* RelationalOperator: '<S774>/Relational Operator' */

  L4_MABX_B.F_Pedal_pwm_sync_fault = (L4_MABX_B.Abs >

    L4_MABX_B.PEDAL_PWM_ANGLE_DEV_MPV);



  /* DataTypeConversion: '<S769>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2 = L4_MABX_B.F_Pedal_pwm_sync_fault;



  /* RelationalOperator: '<S821>/min_relop' incorporates:

   *  Constant: '<S769>/PWMSynchRngMin'

   */

  L4_MABX_B.min_relop_c = (L4_MABX_P.PWMSynchRngMin_Value <

    L4_MABX_B.DataTypeConversion2);



  /* RelationalOperator: '<S821>/max_relop' incorporates:

   *  Constant: '<S769>/PWMSynchRngMax'

   */

  L4_MABX_B.max_relop_o = (L4_MABX_B.DataTypeConversion2 <

    L4_MABX_P.PWMSynchRngMax_Value);



  /* Logic: '<S821>/conjunction' */

  L4_MABX_B.conjunction_h = (L4_MABX_B.min_relop_c && L4_MABX_B.max_relop_o);



  /* UnitDelay: '<S826>/FixPt Unit Delay2' */

  L4_MABX_B.FixPtUnitDelay2_nv = L4_MABX_DW.FixPtUnitDelay2_DSTATE_k;



  /* UnitDelay: '<S826>/FixPt Unit Delay1' */

  L4_MABX_B.Xold_n0 = L4_MABX_DW.FixPtUnitDelay1_DSTATE_e5;



  /* Switch: '<S826>/Init' incorporates:

   *  Constant: '<S769>/PWMSynchFaultLimMin'

   */

  if (L4_MABX_B.FixPtUnitDelay2_nv != 0) {

    L4_MABX_B.Init_e = L4_MABX_P.PWMSynchFaultLimMin_Value;

  } else {

    L4_MABX_B.Init_e = L4_MABX_B.Xold_n0;

  }



  /* End of Switch: '<S826>/Init' */



  /* Sum: '<S822>/FixPt Sum1' incorporates:

   *  Constant: '<S822>/FixPt Constant'

   */

  L4_MABX_B.FixPtSum1_f = L4_MABX_B.Init_e - L4_MABX_P.FixPtConstant_Value_by;



  /* Sum: '<S825>/FixPt Sum1' incorporates:

   *  Constant: '<S825>/FixPt Constant'

   */

  L4_MABX_B.FixPtSum1_l = L4_MABX_B.Init_e + L4_MABX_P.FixPtConstant_Value_oy;



  /* Outputs for Atomic SubSystem: '<S788>/If_Then_Else3' */

  L4_MABX_If_Then_Else(L4_MABX_B.conjunction_h, L4_MABX_B.FixPtSum1_f,

                       L4_MABX_B.FixPtSum1_l, &L4_MABX_B.If_Then_Else3_fz);



  /* End of Outputs for SubSystem: '<S788>/If_Then_Else3' */



  /* RelationalOperator: '<S823>/Relational Operator1' incorporates:

   *  Constant: '<S769>/PWMSynchFaultLimMax'

   */

  L4_MABX_B.RelationalOperator1_g = (L4_MABX_B.If_Then_Else3_fz.Switch >=

    L4_MABX_P.PWMSynchFaultLimMax_Value);



  /* RelationalOperator: '<S823>/Relational Operator' incorporates:

   *  Constant: '<S769>/PWMSynchFaultLimMin'

   */

  L4_MABX_B.RelationalOperator_h = (L4_MABX_B.If_Then_Else3_fz.Switch <=

    L4_MABX_P.PWMSynchFaultLimMin_Value);



  /* Outputs for Atomic SubSystem: '<S823>/If_Then_Else1' */



  /* Constant: '<S769>/PWMSynchFaultLimMin' */

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator_h,

                       L4_MABX_P.PWMSynchFaultLimMin_Value,

                       L4_MABX_B.If_Then_Else3_fz.Switch,

                       &L4_MABX_B.If_Then_Else1_o);



  /* End of Outputs for SubSystem: '<S823>/If_Then_Else1' */



  /* Outputs for Atomic SubSystem: '<S823>/If_Then_Else' */



  /* Constant: '<S769>/PWMSynchFaultLimMax' */

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator1_g,

                       L4_MABX_P.PWMSynchFaultLimMax_Value,

                       L4_MABX_B.If_Then_Else1_o.Switch,

                       &L4_MABX_B.If_Then_Else_j);



  /* End of Outputs for SubSystem: '<S823>/If_Then_Else' */



  /* RelationalOperator: '<S788>/Relational Operator8' incorporates:

   *  Constant: '<S769>/PWMSynchFaultLimMax'

   */

  L4_MABX_B.F_Fault_Hard_pe = (L4_MABX_P.PWMSynchFaultLimMax_Value <=

    L4_MABX_B.If_Then_Else_j.Switch);



  /* Logic: '<S750>/Logical Operator6' */

  L4_MABX_B.LogicalOperator6_o = (L4_MABX_B.F_Pedal_pwm_sens_total_failure ||

    L4_MABX_B.F_Fault_Hard_pe);



  /* Outputs for Enabled SubSystem: '<S750>/Slew_at_event' incorporates:

   *  EnablePort: '<S773>/Enable'

   */

  /* Constant: '<S750>/F_PEDAL_TORQUE_SLEW_AT_FAULT' */

  if (L4_MABX_P.F_PEDAL_TORQUE_SLEW_AT_FAULT_Va) {

    if (!L4_MABX_DW.Slew_at_event_MODE) {

      /* InitializeConditions for UnitDelay: '<S844>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_jr =

        L4_MABX_P.Unit_Delay_InitialCondition_e2j;



      /* InitializeConditions for UnitDelay: '<S845>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_jz = L4_MABX_P.Unit_Delay_InitialCondition_g1;



      /* InitializeConditions for UnitDelay: '<S848>/FixPt Unit Delay2' */

      L4_MABX_DW.FixPtUnitDelay2_DSTATE_b =

        L4_MABX_P.FixPtUnitDelay2_InitialCondi_a4;



      /* InitializeConditions for UnitDelay: '<S848>/FixPt Unit Delay1' */

      L4_MABX_DW.FixPtUnitDelay1_DSTATE_o =

        L4_MABX_P.FixPtUnitDelay1_InitialCondit_i;



      /* InitializeConditions for UnitDelay: '<S843>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_hg = L4_MABX_P.Unit_Delay_InitialCondition_nk;

      L4_MABX_DW.Slew_at_event_MODE = true;

    }



    /* UnitDelay: '<S844>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_fgg = L4_MABX_DW.Unit_Delay_DSTATE_jr;



    /* Logic: '<S844>/Logical Operator1' */

    L4_MABX_B.LogicalOperator1_a = !L4_MABX_B.Unit_Delay_fgg;



    /* Logic: '<S844>/Logical Operator' */

    L4_MABX_B.LogicalOperator_k = (L4_MABX_B.LogicalOperator6_o &&

      L4_MABX_B.LogicalOperator1_a);



    /* UnitDelay: '<S845>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_jr = L4_MABX_DW.Unit_Delay_DSTATE_jz;



    /* Logic: '<S845>/Logical Operator1' */

    L4_MABX_B.LogicalOperator1_l = (L4_MABX_B.LogicalOperator_k ||

      L4_MABX_B.Unit_Delay_jr);



    /* UnitDelay: '<S848>/FixPt Unit Delay2' */

    L4_MABX_B.FixPtUnitDelay2_k = L4_MABX_DW.FixPtUnitDelay2_DSTATE_b;



    /* UnitDelay: '<S848>/FixPt Unit Delay1' */

    L4_MABX_B.Xold_d = L4_MABX_DW.FixPtUnitDelay1_DSTATE_o;



    /* Switch: '<S848>/Init' incorporates:

     *  Constant: '<S750>/PEDAL_PWM_SENSOR_DATA_APV.DEFAULT_VALUE'

     */

    if (L4_MABX_B.FixPtUnitDelay2_k != 0) {

      L4_MABX_B.Init_c = L4_MABX_P.PEDAL_PWM_SENSOR_DATA_APVDEFAUL;

    } else {

      L4_MABX_B.Init_c = L4_MABX_B.Xold_d;

    }



    /* End of Switch: '<S848>/Init' */



    /* Abs: '<S845>/Abs' incorporates:

     *  Constant: '<S750>/PEDAL_PWM_SENSOR_DATA_APV.DEFAULT_SLEW_UP'

     */

    L4_MABX_B.Abs_k = fabs(L4_MABX_P.PEDAL_PWM_SENSOR_DATA_APVDEFA_k);



    /* Product: '<S845>/Product1' incorporates:

     *  Constant: '<S750>/PEDAL_PWM_SENSOR_DATA_APV.DT'

     */

    L4_MABX_B.Product1_m = L4_MABX_B.Abs_k *

      L4_MABX_P.PEDAL_PWM_SENSOR_DATA_APVDT_Val;



    /* Sum: '<S845>/Add1' */

    L4_MABX_B.Add1_h = L4_MABX_B.Init_c + L4_MABX_B.Product1_m;



    /* MinMax: '<S845>/MinMax2' incorporates:

     *  Constant: '<S750>/PEDAL_PWM_SENSOR_DATA_APV.DEFAULT_VALUE'

     */

    DeltaTime = L4_MABX_P.PEDAL_PWM_SENSOR_DATA_APVDEFAUL;

    PositionFinalLimited = L4_MABX_B.Add1_h;

    if ((DeltaTime < PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

      PositionFinalLimited = DeltaTime;

    }



    L4_MABX_B.MinMax2 = PositionFinalLimited;



    /* End of MinMax: '<S845>/MinMax2' */



    /* Abs: '<S845>/Abs1' incorporates:

     *  Constant: '<S750>/PEDAL_PWM_SENSOR_DATA_APV.DEFAULT_SLEW_DOWN'

     */

    L4_MABX_B.Abs1 = fabs(L4_MABX_P.PEDAL_PWM_SENSOR_DATA_APVDEFA_b);



    /* Product: '<S845>/Product2' incorporates:

     *  Constant: '<S750>/PEDAL_PWM_SENSOR_DATA_APV.DT'

     */

    L4_MABX_B.Product2_d = L4_MABX_P.PEDAL_PWM_SENSOR_DATA_APVDT_Val *

      L4_MABX_B.Abs1;



    /* Sum: '<S845>/Subtract1' */

    L4_MABX_B.Subtract1_p = L4_MABX_B.Init_c - L4_MABX_B.Product2_d;



    /* MinMax: '<S845>/MinMax1' */

    DeltaTime = L4_MABX_B.MinMax2;

    PositionFinalLimited = L4_MABX_B.Subtract1_p;

    if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

      PositionFinalLimited = DeltaTime;

    }



    L4_MABX_B.MinMax1_e = PositionFinalLimited;



    /* End of MinMax: '<S845>/MinMax1' */



    /* Outputs for Atomic SubSystem: '<S845>/If_Then_Else' */

    L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator1_l,

                         L4_MABX_B.If_Then_Else_o.Switch, L4_MABX_B.MinMax1_e,

                         &L4_MABX_B.If_Then_Else_or);



    /* End of Outputs for SubSystem: '<S845>/If_Then_Else' */



    /* Sum: '<S773>/Subtract' incorporates:

     *  Constant: '<S750>/PEDAL_PWM_SENSOR_DATA_APV.DEFAULT_VALUE'

     */

    L4_MABX_B.Subtract_j = L4_MABX_P.PEDAL_PWM_SENSOR_DATA_APVDEFAUL -

      L4_MABX_B.If_Then_Else_or.Switch;



    /* Abs: '<S773>/Abs' */

    L4_MABX_B.Abs_i = fabs(L4_MABX_B.Subtract_j);



    /* RelationalOperator: '<S773>/Relational Operator1' incorporates:

     *  Constant: '<S773>/Constant1'

     */

    L4_MABX_B.RelationalOperator1_g4 = (L4_MABX_B.Abs_i <=

      L4_MABX_P.Constant1_Value_b);



    /* Logic: '<S843>/Logical Operator3' */

    L4_MABX_B.LogicalOperator3_b = !L4_MABX_B.RelationalOperator1_g4;



    /* UnitDelay: '<S843>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_h = L4_MABX_DW.Unit_Delay_DSTATE_hg;



    /* Logic: '<S843>/Logical Operator1' */

    L4_MABX_B.LogicalOperator1_g = (L4_MABX_B.LogicalOperator6_o ||

      L4_MABX_B.Unit_Delay_h);



    /* Logic: '<S843>/Logical Operator' */

    L4_MABX_B.LogicalOperator_np = (L4_MABX_B.LogicalOperator3_b &&

      L4_MABX_B.LogicalOperator1_g);



    /* Logic: '<S843>/Logical Operator2' */

    L4_MABX_B.LogicalOperator2_i = !L4_MABX_B.LogicalOperator_np;



    /* RelationalOperator: '<S846>/min_relop' incorporates:

     *  Constant: '<S750>/PEDAL_PWM_SENSOR_DATA_APV.DEFAULT_SLEW_UP'

     *  Constant: '<S846>/min_val'

     */

    L4_MABX_B.min_relop_b = (L4_MABX_P.CheckStaticLowerBound_min_a <=

      L4_MABX_P.PEDAL_PWM_SENSOR_DATA_APVDEFA_k);



    /* Assertion: '<S846>/Assertion' */

    utAssert(L4_MABX_B.min_relop_b);

  } else {

    if (L4_MABX_DW.Slew_at_event_MODE) {

      /* Disable for Outport: '<S773>/F_Out_slewing' */

      L4_MABX_B.LogicalOperator_np = L4_MABX_P.F_Out_slewing_Y0_a;



      /* Disable for Outport: '<S773>/Out' */

      L4_MABX_B.If_Then_Else_or.Switch = L4_MABX_P.Out_Y0_h;

      L4_MABX_DW.Slew_at_event_MODE = false;

    }

  }



  /* End of Constant: '<S750>/F_PEDAL_TORQUE_SLEW_AT_FAULT' */

  /* End of Outputs for SubSystem: '<S750>/Slew_at_event' */



  /* Outputs for Atomic SubSystem: '<S750>/If_Then_Else' */

  L4_MABX_If_Then_Else_kn(L4_MABX_B.LogicalOperator_np,

    L4_MABX_B.If_Then_Else_or.Switch, L4_MABX_B.If_Then_Else_o.Switch);



  /* End of Outputs for SubSystem: '<S750>/If_Then_Else' */



  /* S-Function (rti_commonblock): '<S738>/S-Function1' */

  /* This comment workarounds a code generation problem */

  {

    /* dSPACE I/O Board DS1401STDADCT4 #1 Unit:ADC Group:ADC */

    adc_tp4_single_new_read(ADC_TP4_1_MODULE_ADDR,

      ADC_TP4_CH3,

      (dsfloat *)&L4_MABX_B.SFunction1);

  }



  /* Gain: '<S422>/KL15_Monitor' */

  L4_MABX_B.IgnitionKeySwitch_voltage = L4_MABX_P.KL15_Monitor_Gain *

    L4_MABX_B.SFunction1;



  /* Outputs for Enabled SubSystem: '<S513>/CCVS1_31' incorporates:

   *  EnablePort: '<S514>/Enable'

   */

  /* Constant: '<S436>/Constant' */

  if (L4_MABX_P.Constant_Value_ab) {

    /* S-Function (rti_commonblock): '<S514>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "CCVS1_31" Id:419361073 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEF131].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEF131].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o21_e = 1.0;

        L4_MABX_B.SFunction1_o22_ih = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEF131].timestamp;

        L4_MABX_B.SFunction1_o23_i = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEF131].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEF131].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "TwoSpeedAxleSwitch" (0|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o1_kp = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ParkingBrakeSwitch" (2|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o2_bl = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "CruiseCtrlPauseSwitch" (4|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o3_g2 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ParkBrakeReleaseInhibitRq" (6|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o4_bx = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "WheelBasedVehicleSpeed" (8|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o5_p1 = 0.00390625 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) );



            /* ...... "CruiseCtrlActive" (24|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o6_pt = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "CruiseCtrlEnableSwitch" (26|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o7_g = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "BrakeSwitch" (28|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o8_fp = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ClutchSwitch" (30|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o9_gg = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "CruiseCtrlSetSwitch" (32|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o10_cf = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "CruiseCtrlCoastSwitch" (34|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o11_dy = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "CruiseCtrlResumeSwitch" (36|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o12_j = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "CruiseCtrlAccelerateSwitch" (38|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o13_og = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "CruiseCtrlSetSpeed" (40|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o14_p = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "PTOGovernorState" (48|5, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x0000001F;

            L4_MABX_B.SFunction1_o15_h = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "CruiseCtrlStates" (53|3, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 5;

            CAN_Sgn.UnsignedSgn &= 0x00000007;

            L4_MABX_B.SFunction1_o16_m = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EngIdleIncrementSwitch" (56|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o17_k = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EngIdleDecrementSwitch" (58|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o18_a = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EngTestModeSwitch" (60|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o19_i = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EngShutdownOverrideSwitch" (62|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o20_i = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o21_e = 0.0;

      }

    }

  }



  /* End of Constant: '<S436>/Constant' */

  /* End of Outputs for SubSystem: '<S513>/CCVS1_31' */



  /* Outputs for Enabled SubSystem: '<S524>/EBC2_0B1' incorporates:

   *  EnablePort: '<S525>/Enable'

   */

  /* Constant: '<S441>/Enable_RX_EBC2_0B' */

  if (L4_MABX_P.Enable_RX_EBC2_0B_Value) {

    /* S-Function (rti_commonblock): '<S525>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "EBC2_0B" Id:419348235 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEBF0B].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEBF0B].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o8_bo = 1.0;

        L4_MABX_B.SFunction1_o9_a = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEBF0B].timestamp;

        L4_MABX_B.SFunction1_o10_pk = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEBF0B].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEBF0B].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "FrontAxleSpeed" (0|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o1_gd = 0.00390625 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) );



            /* ...... "RelativeSpeedFrontAxleLeftWheel" (16|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o2_dl = -7.8125 + ( 0.0625 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) ) );



            /* ...... "RlativeSpeedFrontAxleRightWheel" (24|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o3_hh = -7.8125 + ( 0.0625 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) ) );



            /* ...... "RelativeSpeedRearAxle1LeftWheel" (32|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o4_cs = -7.8125 + ( 0.0625 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) ) );



            /* ...... "RlativeSpeedRearAxle1RightWheel" (40|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o5_o = -7.8125 + ( 0.0625 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) ) );



            /* ...... "RelativeSpeedRearAxle2LeftWheel" (48|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o6_la = -7.8125 + ( 0.0625 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) ) );



            /* ...... "RlativeSpeedRearAxle2RightWheel" (56|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o7_lp = -7.8125 + ( 0.0625 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) ) );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o8_bo = 0.0;

      }

    }

  }



  /* End of Constant: '<S441>/Enable_RX_EBC2_0B' */

  /* End of Outputs for SubSystem: '<S524>/EBC2_0B1' */



  /* Outputs for Enabled SubSystem: '<S582>/HRW_0B' incorporates:

   *  EnablePort: '<S583>/Enable'

   */

  /* Constant: '<S448>/Enable_HRW_RX_0B' */

  if (L4_MABX_P.Enable_HRW_RX_0B_Value) {

    /* S-Function (rti_commonblock): '<S583>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "HRW_0B" Id:150892043 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x8FE6E0B].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x8FE6E0B].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o5_ij = 1.0;

        L4_MABX_B.SFunction1_o6_kk = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x8FE6E0B].timestamp;

        L4_MABX_B.SFunction1_o7_cp = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x8FE6E0B].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x8FE6E0B].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "FrontAxleLeftWheelSpeed" (0|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o1_au = 0.00390625 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) );



            /* ...... "FrontAxleRightWheelSpeed" (16|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o2_hu = 0.00390625 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) );



            /* ...... "RearAxleLeftWheelSpeed" (32|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o3_pw = 0.00390625 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) );



            /* ...... "RearAxleRightWheelSpeed" (48|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o4_auj = 0.00390625 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o5_ij = 0.0;

      }

    }

  }



  /* End of Constant: '<S448>/Enable_HRW_RX_0B' */

  /* End of Outputs for SubSystem: '<S582>/HRW_0B' */



  /* Outputs for Enabled SubSystem: '<S522>/EBC1_0B' incorporates:

   *  EnablePort: '<S523>/Enable'

   */

  /* Constant: '<S440>/Constant1' */

  if (L4_MABX_P.Constant1_Value_nw) {

    /* S-Function (rti_commonblock): '<S523>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "EBC1_0B" Id:418382219 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18F0018B].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18F0018B].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o23_b = 1.0;

        L4_MABX_B.SFunction1_o24_l = (real_T)

          can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18F0018B].timestamp;

        L4_MABX_B.SFunction1_o25_p = (real_T)

          can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18F0018B].deltatime;

        CAN_Msg = can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18F0018B].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "ASREngCtrlActive" (0|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o1_df = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ASRBrakeCtrlActive" (2|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o2_eb = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "AntiLockBrakingActive" (4|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o3_kb = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EBSBrakeSwitch" (6|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o4_nj = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "BrakePedalPos" (8|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o5_k3 = 0.4 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "ABSOffroadSwitch" (16|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o6_hu = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ASROffroadSwitch" (18|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o7_k = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ASRHillHolderSwitch" (20|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o8_lb = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "TractionCtrlOverrideSwitch" (22|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o9_oz = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "AccelInterlockSwitch" (24|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o10_dd = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EngDerateSwitch" (26|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o11_a2 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EngAuxShutdownSwitch" (28|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o12_c = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "RemoteAccelEnableSwitch" (30|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o13_o = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EngRetarderSelection" (32|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o14_l = 0.4 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "ABSFullyOperational" (40|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o15_a = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EBSRedWarningSignal" (42|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o16_ed = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ABS_EBSAmberWarningSignal" (44|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o17_d = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ATC_ASRInformationSignal" (46|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o18_c = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SrcAddrssOfCtrllngDvcFrBrkCntrl" (48|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o19_o = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "HaltBrakeSwitch" (58|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o20_e = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "TrailerABSStatus" (60|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o21_f = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "TrctrMntdTrilerABSWarningSignal" (62|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o22_o = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o23_b = 0.0;

      }

    }

  }



  /* End of Constant: '<S440>/Constant1' */

  /* End of Outputs for SubSystem: '<S522>/EBC1_0B' */



  /* Outputs for Enabled SubSystem: '<S577>/ETC2_031' incorporates:

   *  EnablePort: '<S578>/Enable'

   */

  /* Constant: '<S446>/Enable_RX_ETC2_03' */

  if (L4_MABX_P.Enable_RX_ETC2_03_Value) {

    /* S-Function (rti_commonblock): '<S578>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "ETC2_03" Id:418383107 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F00503].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F00503].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o4_ly = 1.0;

        L4_MABX_B.SFunction1_o5_e3 = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F00503].timestamp;

        L4_MABX_B.SFunction1_o6_o = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F00503].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F00503].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "SPN524_TransSelectedGear" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_nm = -125 + ( ((real_T) CAN_Sgn.UnsignedSgn)

              );



            /* ...... "SPN526_TransActualGearRatio" (8|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o2_mp = 0.001 * ( ((real_T) CAN_Sgn.UnsignedSgn)

              );



            /* ...... "SPN523_TransCurrentGear" (24|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o3_cn = -125 + ( ((real_T) CAN_Sgn.UnsignedSgn)

              );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o4_ly = 0.0;

      }

    }

  }



  /* End of Constant: '<S446>/Enable_RX_ETC2_03' */

  /* End of Outputs for SubSystem: '<S577>/ETC2_031' */



  /* DataTypeConversion: '<S577>/Data Type Conversion1' */

  L4_MABX_B.SPN524_TransSelectedGear = L4_MABX_B.SFunction1_o1_nm;



  /* DataTypeConversion: '<S577>/Data Type Conversion2' */

  L4_MABX_B.SPN523_TransCurrentGear = L4_MABX_B.SFunction1_o3_cn;



  /* DataTypeConversion: '<S577>/Data Type Conversion3' */

  L4_MABX_B.SPN526_TransActualGearRatio = L4_MABX_B.SFunction1_o2_mp;



  /* Outputs for Enabled SubSystem: '<S571>/EEC1_001' incorporates:

   *  EnablePort: '<S572>/Enable'

   */

  /* Constant: '<S443>/Enable_RX_EEC1_00' */

  if (L4_MABX_P.Enable_RX_EEC1_00_Value) {

    /* S-Function (rti_commonblock): '<S572>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "EEC1_00" Id:217056256 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCF00400].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCF00400].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o9_gn = 1.0;

        L4_MABX_B.SFunction1_o10_b = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCF00400].timestamp;

        L4_MABX_B.SFunction1_o11_b = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCF00400].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCF00400].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "EngTorqueMode" (0|4, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x0000000F;

            L4_MABX_B.SFunction1_o1_nr = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ActlEngPrcntTrqueHighResolution" (4|4, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x0000000F;

            L4_MABX_B.SFunction1_o2_dgu = 0.125 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) );



            /* ...... "DriversDemandEngPercentTorque" (8|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o3_ho = -125 + ( ((real_T) CAN_Sgn.UnsignedSgn)

              );



            /* ...... "ActualEngPercentTorque" (16|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o4_ki = -125 + ( ((real_T) CAN_Sgn.UnsignedSgn)

              );



            /* ...... "EngSpeed" (24|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o5_nl = 0.125 * ( ((real_T) CAN_Sgn.UnsignedSgn)

              );



            /* ...... "SrcAddrssOfCtrllngDvcFrEngCntrl" (40|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o6_hc = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EngStarterMode" (48|4, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x0000000F;

            L4_MABX_B.SFunction1_o7_ln = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EngDemandPercentTorque" (56|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o8_f = -125 + ( ((real_T) CAN_Sgn.UnsignedSgn) );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o9_gn = 0.0;

      }

    }

  }



  /* End of Constant: '<S443>/Enable_RX_EEC1_00' */

  /* End of Outputs for SubSystem: '<S571>/EEC1_001' */



  /* Outputs for Enabled SubSystem: '<S575>/EEC3_001' incorporates:

   *  EnablePort: '<S576>/Enable'

   */

  /* Constant: '<S445>/Enable_RX_EEC3_00' */

  if (L4_MABX_P.Enable_RX_EEC3_00_Value) {

    /* S-Function (rti_commonblock): '<S576>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "EEC3_00" Id:419356416 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEDF00].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEDF00].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o3_fy = 1.0;

        L4_MABX_B.SFunction1_o4_lo = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEDF00].timestamp;

        L4_MABX_B.SFunction1_o5_jl = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEDF00].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEDF00].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "SPN514_NominalFrictionPercentTorque" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_g = -125 + ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "SPN2978_EstEngParasiticLossesPercentTorque" (32|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o2_ky = -125 + ( ((real_T) CAN_Sgn.UnsignedSgn)

              );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o3_fy = 0.0;

      }

    }

  }



  /* End of Constant: '<S445>/Enable_RX_EEC3_00' */

  /* End of Outputs for SubSystem: '<S575>/EEC3_001' */



  /* DataTypeConversion: '<S575>/Data Type Conversion2' */

  L4_MABX_B.SPN514_NominalFrictionPercentTo = L4_MABX_B.SFunction1_o1_g;



  /* DataTypeConversion: '<S575>/Data Type Conversion1' */

  L4_MABX_B.SPN2978_EstEngParasiticLossesPe = L4_MABX_B.SFunction1_o2_ky;



  /* Outputs for Enabled SubSystem: '<S518>/CVW_0B1' incorporates:

   *  EnablePort: '<S519>/Enable'

   */

  /* Constant: '<S438>/Constant' */

  if (L4_MABX_P.Constant_Value_gk) {

    /* S-Function (rti_commonblock): '<S519>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "CVW_0B" Id:419328011 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FE700B].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FE700B].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o2_bq = 1.0;

        L4_MABX_B.SFunction1_o3_dd = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FE700B].timestamp;

        L4_MABX_B.SFunction1_o4_ha = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FE700B].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FE700B].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "SPN1760_GrossCombinationVehicleWeight" (16|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o1_kzx = 10 * ( ((real_T) CAN_Sgn.UnsignedSgn) );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o2_bq = 0.0;

      }

    }

  }



  /* End of Constant: '<S438>/Constant' */

  /* End of Outputs for SubSystem: '<S518>/CVW_0B1' */



  /* DataTypeConversion: '<S518>/Data Type Conversion1' */

  L4_MABX_B.SPN1760_GrossCombinationVehicle = L4_MABX_B.SFunction1_o1_kzx;



  /* Outputs for Enabled SubSystem: '<S499>/ACC1_2A_' incorporates:

   *  EnablePort: '<S500>/Enable'

   */

  /* Constant: '<S429>/Constant' */

  if (L4_MABX_P.Constant_Value_ch) {

    /* S-Function (rti_commonblock): '<S500>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "ACC1_2A" Id:285110058 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x10FE6F2A].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x10FE6F2A].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o11_mg = 1.0;

        L4_MABX_B.SFunction1_o12_n = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x10FE6F2A].timestamp;

        L4_MABX_B.SFunction1_o13_or = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x10FE6F2A].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x10FE6F2A].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "SpeedOfForwardVehicle" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_de = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "DistanceToForwardVehicle" (8|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o2_d5 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "AdaptiveCruiseCtrlSetSpeed" (16|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o3_dg = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "AdaptiveCruiseCtrlMode" (24|3, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x00000007;

            L4_MABX_B.SFunction1_o4_bc = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "AdptveCruiseCtrlSetDistanceMode" (27|3, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 3;

            CAN_Sgn.UnsignedSgn &= 0x00000007;

            L4_MABX_B.SFunction1_o5_k4 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "RoadCurvature" (32|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o6_j5 = -250 + ( 0.0078125 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) ) );



            /* ...... "ACCTargetDetected" (48|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o7_hh = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ACCSystemShutoffWarning" (50|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o8_oi = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ACCDistanceAlertSignal" (52|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o9_ih = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ForwardCollisionWarning" (54|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o10_py = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o11_mg = 0.0;

      }

    }

  }



  /* End of Constant: '<S429>/Constant' */

  /* End of Outputs for SubSystem: '<S499>/ACC1_2A_' */



  /* DataTypeConversion: '<S499>/Data Type Conversion12' */

  L4_MABX_B.ACCDistanceAlertSignal = L4_MABX_B.SFunction1_o9_ih;



  /* DataTypeConversion: '<S499>/Data Type Conversion13' */

  L4_MABX_B.ForwardCollisionWarning = L4_MABX_B.SFunction1_o10_py;



  /* RelationalOperator: '<S484>/Operator' incorporates:

   *  Constant: '<S427>/Constant'

   *  Constant: '<S482>/Constant'

   */

  L4_MABX_B.Operator_nq = (L4_MABX_P.Constant_Value_by3 ==

    L4_MABX_P.Constant_Value_jb);



  /* Outputs for Enabled SubSystem: '<S481>/CAN_TYPE1_RX_M1_C1' incorporates:

   *  EnablePort: '<S483>/Enable'

   */

  if (L4_MABX_B.Operator_nq) {

    /* S-Function (rti_commonblock): '<S483>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "TPCM_FF_00" Id:485293824 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x1CECFF00].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x1CECFF00].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o9_ad = 1.0;

        L4_MABX_B.SFunction1_o10_n = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x1CECFF00].timestamp;

        L4_MABX_B.SFunction1_o11_p = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x1CECFF00].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x1CECFF00].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "byte1" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_bv = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte2" (8|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o2_kv = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte3" (16|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o3_j2 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte4" (24|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o4_fp = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte5" (32|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o5_mi = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte6" (40|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o6_kp = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte7" (48|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o7_gb = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte8" (56|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o8_ez = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o9_ad = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S481>/CAN_TYPE1_RX_M1_C1' */



  /* DataTypeConversion: '<S481>/Data Type Conversion' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o1_bv;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion_ab = starting_index;



  /* End of DataTypeConversion: '<S481>/Data Type Conversion' */



  /* DataTypeConversion: '<S481>/Data Type Conversion1' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o2_kv;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion1_i5 = starting_index;



  /* End of DataTypeConversion: '<S481>/Data Type Conversion1' */



  /* DataTypeConversion: '<S481>/Data Type Conversion2' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o3_j2;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion2_ev = starting_index;



  /* End of DataTypeConversion: '<S481>/Data Type Conversion2' */



  /* DataTypeConversion: '<S481>/Data Type Conversion3' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o4_fp;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion3_f = starting_index;



  /* End of DataTypeConversion: '<S481>/Data Type Conversion3' */



  /* DataTypeConversion: '<S481>/Data Type Conversion4' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o5_mi;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion4_e = starting_index;



  /* End of DataTypeConversion: '<S481>/Data Type Conversion4' */



  /* DataTypeConversion: '<S481>/Data Type Conversion5' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o6_kp;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion5_h = starting_index;



  /* End of DataTypeConversion: '<S481>/Data Type Conversion5' */



  /* DataTypeConversion: '<S481>/Data Type Conversion6' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o7_gb;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion6_nf = starting_index;



  /* End of DataTypeConversion: '<S481>/Data Type Conversion6' */



  /* DataTypeConversion: '<S481>/Data Type Conversion7' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o8_ez;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion7_f = starting_index;



  /* End of DataTypeConversion: '<S481>/Data Type Conversion7' */



  /* MultiPortSwitch: '<S427>/Multiport_Switch' */

  L4_MABX_B.RawData[0] = L4_MABX_B.DataTypeConversion_ab;

  L4_MABX_B.RawData[1] = L4_MABX_B.DataTypeConversion1_i5;

  L4_MABX_B.RawData[2] = L4_MABX_B.DataTypeConversion2_ev;

  L4_MABX_B.RawData[3] = L4_MABX_B.DataTypeConversion3_f;

  L4_MABX_B.RawData[4] = L4_MABX_B.DataTypeConversion4_e;

  L4_MABX_B.RawData[5] = L4_MABX_B.DataTypeConversion5_h;

  L4_MABX_B.RawData[6] = L4_MABX_B.DataTypeConversion6_nf;

  L4_MABX_B.RawData[7] = L4_MABX_B.DataTypeConversion7_f;



  /* DataTypeConversion: '<S475>/Data Type Conversion' */

  for (i = 0; i < 8; i++) {

    L4_MABX_B.DataTypeConversion_j2[i] = L4_MABX_B.RawData[i];

  }



  /* End of DataTypeConversion: '<S475>/Data Type Conversion' */



  /* RelationalOperator: '<S701>/Operator' incorporates:

   *  Constant: '<S475>/Constant3'

   */

  L4_MABX_B.Operator_b4 = (L4_MABX_B.DataTypeConversion_j2[0] ==

    L4_MABX_P.Constant3_Value_e0);



  /* Outputs for Enabled SubSystem: '<S475>/Decode_TPCM_BAM' incorporates:

   *  EnablePort: '<S693>/Enable'

   */

  if (L4_MABX_B.Operator_b4) {

    /* SignalConversion: '<S704>/Signal Conversion' */

    L4_MABX_B.SPN2556_ControlByte_n = L4_MABX_B.DataTypeConversion_j2[0];



    /* DataTypeConversion: '<S705>/Data Type Conversion' */

    L4_MABX_B.DataTypeConversion_dp = L4_MABX_B.DataTypeConversion_j2[1];



    /* DataTypeConversion: '<S705>/Data Type Conversion1' */

    L4_MABX_B.DataTypeConversion1_ke = L4_MABX_B.DataTypeConversion_j2[2];



    /* ArithShift: '<S705>/Shift Arithmetic2' */

    L4_MABX_B.ShiftArithmetic2_b = (uint16_T)(L4_MABX_B.DataTypeConversion1_ke <<

      8);



    /* S-Function (sfix_bitop): '<S708>/Operator' */

    L4_MABX_B.Operator_lbu = (uint16_T)(L4_MABX_B.DataTypeConversion_dp |

      L4_MABX_B.ShiftArithmetic2_b);



    /* DataTypeConversion: '<S708>/DataType' */

    L4_MABX_B.DataType_h1 = L4_MABX_B.Operator_lbu;



    /* SignalConversion: '<S706>/Signal Conversion' */

    L4_MABX_B.SPN2568_TotalNumberOfPackets = L4_MABX_B.DataTypeConversion_j2[3];



    /* DataTypeConversion: '<S707>/Data Type Conversion' */

    L4_MABX_B.DataTypeConversion_e = L4_MABX_B.DataTypeConversion_j2[5];



    /* DataTypeConversion: '<S707>/Data Type Conversion1' */

    L4_MABX_B.DataTypeConversion1_fn = L4_MABX_B.DataTypeConversion_j2[6];



    /* DataTypeConversion: '<S707>/Data Type Conversion2' */

    L4_MABX_B.DataTypeConversion2_iv = L4_MABX_B.DataTypeConversion_j2[7];



    /* ArithShift: '<S707>/Shift Arithmetic1' */

    L4_MABX_B.ShiftArithmetic1_b = L4_MABX_B.DataTypeConversion1_fn << 8;



    /* ArithShift: '<S707>/Shift Arithmetic2' */

    L4_MABX_B.ShiftArithmetic2_f = L4_MABX_B.DataTypeConversion2_iv << 16;



    /* S-Function (sfix_bitop): '<S709>/Operator' */

    L4_MABX_B.Operator_j = L4_MABX_B.DataTypeConversion_e |

      L4_MABX_B.ShiftArithmetic1_b | L4_MABX_B.ShiftArithmetic2_f;



    /* DataTypeConversion: '<S709>/DataType' */

    L4_MABX_B.DataType_jy = L4_MABX_B.Operator_j;

  }



  /* End of Outputs for SubSystem: '<S475>/Decode_TPCM_BAM' */



  /* RelationalOperator: '<S493>/Operator' incorporates:

   *  Constant: '<S428>/Constant'

   *  Constant: '<S491>/Constant'

   */

  L4_MABX_B.Operator_km = (L4_MABX_P.Constant_Value_ek ==

    L4_MABX_P.Constant_Value_pp);



  /* Outputs for Enabled SubSystem: '<S490>/CAN_TYPE1_RX_M1_C1' incorporates:

   *  EnablePort: '<S492>/Enable'

   */

  if (L4_MABX_B.Operator_km) {

    /* S-Function (rti_commonblock): '<S492>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "TPDT_FF_00" Id:485228288 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x1CEBFF00].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x1CEBFF00].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o9_dt = 1.0;

        L4_MABX_B.SFunction1_o10_hj = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x1CEBFF00].timestamp;

        L4_MABX_B.SFunction1_o11_h = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x1CEBFF00].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x1CEBFF00].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "byte1" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_jh = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte2" (8|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o2_e2 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte3" (16|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o3_id = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte4" (24|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o4_jm = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte5" (32|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o5_h = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte6" (40|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o6_c = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte7" (48|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o7_dv = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte8" (56|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o8_of = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o9_dt = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S490>/CAN_TYPE1_RX_M1_C1' */



  /* DataTypeConversion: '<S490>/Data Type Conversion' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o1_jh;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion_by = starting_index;



  /* End of DataTypeConversion: '<S490>/Data Type Conversion' */



  /* DataTypeConversion: '<S490>/Data Type Conversion1' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o2_e2;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion1_ni = starting_index;



  /* End of DataTypeConversion: '<S490>/Data Type Conversion1' */



  /* DataTypeConversion: '<S490>/Data Type Conversion2' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o3_id;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion2_ge = starting_index;



  /* End of DataTypeConversion: '<S490>/Data Type Conversion2' */



  /* DataTypeConversion: '<S490>/Data Type Conversion3' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o4_jm;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion3_i4 = starting_index;



  /* End of DataTypeConversion: '<S490>/Data Type Conversion3' */



  /* DataTypeConversion: '<S490>/Data Type Conversion4' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o5_h;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion4_dm = starting_index;



  /* End of DataTypeConversion: '<S490>/Data Type Conversion4' */



  /* DataTypeConversion: '<S490>/Data Type Conversion5' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o6_c;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion5_h3 = starting_index;



  /* End of DataTypeConversion: '<S490>/Data Type Conversion5' */



  /* DataTypeConversion: '<S490>/Data Type Conversion6' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o7_dv;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion6_nc = starting_index;



  /* End of DataTypeConversion: '<S490>/Data Type Conversion6' */



  /* DataTypeConversion: '<S490>/Data Type Conversion7' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o8_of;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion7_k = starting_index;



  /* End of DataTypeConversion: '<S490>/Data Type Conversion7' */



  /* MultiPortSwitch: '<S428>/Multiport_Switch' */

  L4_MABX_B.RawData_i[0] = L4_MABX_B.DataTypeConversion_by;

  L4_MABX_B.RawData_i[1] = L4_MABX_B.DataTypeConversion1_ni;

  L4_MABX_B.RawData_i[2] = L4_MABX_B.DataTypeConversion2_ge;

  L4_MABX_B.RawData_i[3] = L4_MABX_B.DataTypeConversion3_i4;

  L4_MABX_B.RawData_i[4] = L4_MABX_B.DataTypeConversion4_dm;

  L4_MABX_B.RawData_i[5] = L4_MABX_B.DataTypeConversion5_h3;

  L4_MABX_B.RawData_i[6] = L4_MABX_B.DataTypeConversion6_nc;

  L4_MABX_B.RawData_i[7] = L4_MABX_B.DataTypeConversion7_k;



  /* DataTypeConversion: '<S476>/Data Type Conversion' */

  for (i = 0; i < 8; i++) {

    L4_MABX_B.DataTypeConversion_f0[i] = L4_MABX_B.RawData_i[i];

  }



  /* End of DataTypeConversion: '<S476>/Data Type Conversion' */



  /* S-Function (rti_commonblock): '<S854>/S-Function1' */



  /* This comment workarounds a code generation problem */



  /* End of Outputs for S-Function (rti_commonblock): '<S854>/S-Function1' */



  /* RateTransition: '<S423>/Rate Transition' */

  switch (L4_MABX_DW.RateTransition_write_buf) {

   case 0:

    L4_MABX_DW.RateTransition_read_buf = 1;

    break;



   case 1:

    L4_MABX_DW.RateTransition_read_buf = 0;

    break;



   default:

    L4_MABX_DW.RateTransition_read_buf = L4_MABX_DW.RateTransition_last_buf_wr;

    break;

  }



  if (L4_MABX_DW.RateTransition_read_buf != 0) {

    GLB_Absolute_Timestamp = L4_MABX_DW.RateTransition_Buffer1;

  } else {

    GLB_Absolute_Timestamp = L4_MABX_DW.RateTransition_Buffer0;

  }



  L4_MABX_DW.RateTransition_read_buf = -1;



  /* End of RateTransition: '<S423>/Rate Transition' */



  /* DataTypeConversion: '<S490>/Data Type Conversion8' */

  L4_MABX_B.RX_status = (L4_MABX_B.SFunction1_o9_dt != 0.0);



  /* MultiPortSwitch: '<S428>/Multiport_Switch' */

  L4_MABX_B.RX_status_a = L4_MABX_B.RX_status;



  /* RelationalOperator: '<S528>/Operator' incorporates:

   *  Constant: '<S442>/Constant2'

   */

  L4_MABX_B.Operator_no = (L4_MABX_B.DataType_jy == L4_MABX_P.Constant2_Value_ih);



  /* Logic: '<S442>/Logical Operator' */

  L4_MABX_B.LogicalOperator_iz = (L4_MABX_B.RX_status_a && L4_MABX_B.Operator_no);



  /* Outputs for Enabled SubSystem: '<S442>/CAN_RX_EC1_00' incorporates:

   *  EnablePort: '<S526>/Enable'

   */

  if (L4_MABX_B.LogicalOperator_iz) {

    /* UnitDelay: '<S526>/Unit Delay' */

    for (i = 0; i < 39; i++) {

      L4_MABX_B.UnitDelay_bw[i] = L4_MABX_DW.UnitDelay_DSTATE_b3[i];

    }



    /* End of UnitDelay: '<S526>/Unit Delay' */



    /* MATLAB Function: '<S526>/serialize_tpdt' */

    /* MATLAB Function 'INPUTS_PIC_KW/CAN_PIC_KW/CAN_RX_EC1_00/CAN_RX_EC1_00/serialize_tpdt': '<S530>:1' */

    /* '<S530>:1:9' */

    if (L4_MABX_B.DataTypeConversion_f0[0] > 1) {

      /* '<S530>:1:6' */

      /* '<S530>:1:7' */

      for (i = 0; i < 39; i++) {

        L4_MABX_B.Data_d[i] = L4_MABX_B.UnitDelay_bw[i];

      }

    } else {

      /* '<S530>:1:9' */

      for (i = 0; i < 39; i++) {

        L4_MABX_B.Data_d[i] = MAX_uint8_T;

      }

    }



    /* '<S530>:1:11' */

    i = (int32_T)(7U * L4_MABX_B.DataTypeConversion_f0[0]);

    if ((uint32_T)i > 255U) {

      i = 255;

    }



    tmp = i - 6U;

    if (tmp > (uint32_T)i) {

      tmp = 0U;

    }



    i = (int32_T)tmp;

    starting_index = (uint8_T)i;



    /* '<S530>:1:12' */

    L4_MABX_B.Data_d[starting_index - 1] = L4_MABX_B.DataTypeConversion_f0[1];

    L4_MABX_B.Data_d[starting_index] = L4_MABX_B.DataTypeConversion_f0[2];

    L4_MABX_B.Data_d[starting_index + 1] = L4_MABX_B.DataTypeConversion_f0[3];

    L4_MABX_B.Data_d[starting_index + 2] = L4_MABX_B.DataTypeConversion_f0[4];

    L4_MABX_B.Data_d[starting_index + 3] = L4_MABX_B.DataTypeConversion_f0[5];

    L4_MABX_B.Data_d[starting_index + 4] = L4_MABX_B.DataTypeConversion_f0[6];

    L4_MABX_B.Data_d[starting_index + 5] = L4_MABX_B.DataTypeConversion_f0[7];



    /* '<S530>:1:13' */

    L4_MABX_B.RX_status_pz = (L4_MABX_B.DataTypeConversion_f0[0] ==

      L4_MABX_B.SPN2568_TotalNumberOfPackets);



    /* End of MATLAB Function: '<S526>/serialize_tpdt' */



    /* Outputs for Enabled SubSystem: '<S526>/Decode' incorporates:

     *  EnablePort: '<S529>/Enable'

     */

    if (L4_MABX_B.RX_status_pz) {

      /* Inport: '<S529>/Inport' */

      for (i = 0; i < 39; i++) {

        L4_MABX_B.Inport_b[i] = L4_MABX_B.Data_d[i];

      }



      /* End of Inport: '<S529>/Inport' */



      /* Inport: '<S529>/timeStamp' */

      L4_MABX_B.timeStamp_j = GLB_Absolute_Timestamp;



      /* UnitDelay: '<S529>/Unit_Delay' */

      L4_MABX_B.Unit_Delay_i = L4_MABX_DW.Unit_Delay_DSTATE_i;



      /* Sum: '<S529>/Subtract' */

      L4_MABX_B.Subtract_gi = (real32_T)(L4_MABX_B.timeStamp_j -

        L4_MABX_B.Unit_Delay_i);

    }



    /* End of Outputs for SubSystem: '<S526>/Decode' */

  }



  /* End of Outputs for SubSystem: '<S442>/CAN_RX_EC1_00' */



  /* DataTypeConversion: '<S527>/Data Type Conversion' */

  for (i = 0; i < 39; i++) {

    L4_MABX_B.DataTypeConversion_bq[i] = L4_MABX_B.Inport_b[i];

  }



  /* End of DataTypeConversion: '<S527>/Data Type Conversion' */



  /* DataTypeConversion: '<S538>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_gs = L4_MABX_B.DataTypeConversion_bq[19];



  /* DataTypeConversion: '<S538>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_mo = L4_MABX_B.DataTypeConversion_bq[20];



  /* ArithShift: '<S538>/Shift Arithmetic' */

  L4_MABX_B.ShiftArithmetic = (uint16_T)(L4_MABX_B.DataTypeConversion1_mo << 8);



  /* S-Function (sfix_bitop): '<S563>/Operator' */

  L4_MABX_B.Operator_fd = (uint16_T)(L4_MABX_B.DataTypeConversion_gs |

    L4_MABX_B.ShiftArithmetic);



  /* DataTypeConversion: '<S563>/DataType' */

  L4_MABX_B.DataType_gs = L4_MABX_B.Operator_fd;



  /* DataTypeConversion: '<S538>/Data Type Conversion2' */

  L4_MABX_B.SPN544_EngineReferenceTorque = L4_MABX_B.DataType_gs;



  /* Outputs for Enabled SubSystem: '<S648>/VDC1_0B_' incorporates:

   *  EnablePort: '<S649>/Enable'

   */

  /* Constant: '<S462>/Constant' */

  if (L4_MABX_P.Constant_Value_amj) {

    /* S-Function (rti_commonblock): '<S649>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "VDC1_0B" Id:419319563 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FE4F0B].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FE4F0B].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o8_m = 1.0;

        L4_MABX_B.SFunction1_o9_m = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FE4F0B].timestamp;

        L4_MABX_B.SFunction1_o10 = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FE4F0B].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FE4F0B].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "VDCInformationSignal" (0|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o1_n5 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "VDCFullyOperational" (2|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o2_c5 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "VDCBrakeLightRq" (4|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o3_e2 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ROPEngCtrlActive" (8|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o4_lj = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ROPBrakeCtrlActive" (10|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o5_i = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "YCEngCtrlActive" (12|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o6_d = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "YCBrakeCtrlActive" (14|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o7_h = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o8_m = 0.0;

      }

    }

  }



  /* End of Constant: '<S462>/Constant' */

  /* End of Outputs for SubSystem: '<S648>/VDC1_0B_' */



  /* Outputs for Enabled SubSystem: '<S650>/VDC2_0B1' incorporates:

   *  EnablePort: '<S651>/Enable'

   */

  /* Constant: '<S463>/Constant' */

  if (L4_MABX_P.Constant_Value_fl) {

    /* S-Function (rti_commonblock): '<S651>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "VDC2_0B" Id:418384139 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F0090B].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F0090B].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o7_f = 1.0;

        L4_MABX_B.SFunction1_o8_p = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F0090B].timestamp;

        L4_MABX_B.SFunction1_o9 = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F0090B].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F0090B].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "SteerWheelAngle" (0|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            SteerWheelAngle = -31.374 + ( 0.0009765625 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) ) );



            /* ...... "SteerWheelTurnCounter" (16|6, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x0000003F;

            L4_MABX_B.SFunction1_o2_gn = -32 + ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "SteerWheelAngleSensorType" (22|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o3_jk = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "YawRate" (24|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            YawRate = -3.92 + ( 0.0001220703125 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) ) );



            /* ...... "LateralAcceleration" (40|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o5_f = -15.687 + ( 0.00048828125 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) ) );



            /* ...... "LongitudinalAcceleration" (56|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            SPN1810_LongitudinalAcceleration = -12.5 + ( 0.1 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) ) );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o7_f = 0.0;

      }

    }

  }



  /* End of Constant: '<S463>/Constant' */

  /* End of Outputs for SubSystem: '<S650>/VDC2_0B1' */



  /* UnitDelay: '<S655>/Unit_Delay3' */

  L4_MABX_B.Unit_Delay3 = L4_MABX_DW.Unit_Delay3_DSTATE;



  /* RelationalOperator: '<S656>/Operator' incorporates:

   *  Constant: '<S465>/Constant2'

   */

  L4_MABX_B.Operator_h3 = (L4_MABX_B.DataType_jy == L4_MABX_P.Constant2_Value_ok);



  /* Logic: '<S465>/Logical Operator' */

  L4_MABX_B.LogicalOperator_im = (L4_MABX_B.RX_status_a && L4_MABX_B.Operator_h3);



  /* Outputs for Enabled SubSystem: '<S465>/CAN_RX_VI_00' incorporates:

   *  EnablePort: '<S654>/Enable'

   */

  if (L4_MABX_B.LogicalOperator_im) {

    /* UnitDelay: '<S654>/Unit Delay' */

    for (i = 0; i < 17; i++) {

      L4_MABX_B.UnitDelay_h[i] = L4_MABX_DW.UnitDelay_DSTATE_o[i];

    }



    /* End of UnitDelay: '<S654>/Unit Delay' */



    /* MATLAB Function: '<S654>/serialize_tpdt' */

    /* MATLAB Function 'INPUTS_PIC_KW/CAN_PIC_KW/CAN_RX_VI_00/CAN_RX_VI_00/serialize_tpdt': '<S658>:1' */

    /* '<S658>:1:9' */

    if (L4_MABX_B.DataTypeConversion_f0[0] > 1) {

      /* '<S658>:1:6' */

      /* '<S658>:1:7' */

      for (i = 0; i < 17; i++) {

        L4_MABX_B.Data[i] = L4_MABX_B.UnitDelay_h[i];

      }

    } else {

      /* '<S658>:1:9' */

      for (i = 0; i < 17; i++) {

        L4_MABX_B.Data[i] = MAX_uint8_T;

      }

    }



    /* '<S658>:1:11' */

    i = (int32_T)(7U * L4_MABX_B.DataTypeConversion_f0[0]);

    if ((uint32_T)i > 255U) {

      i = 255;

    }



    tmp = i - 6U;

    if (tmp > (uint32_T)i) {

      tmp = 0U;

    }



    i = (int32_T)tmp;

    starting_index = (uint8_T)i;



    /* '<S658>:1:12' */

    L4_MABX_B.Data[starting_index - 1] = L4_MABX_B.DataTypeConversion_f0[1];

    L4_MABX_B.Data[starting_index] = L4_MABX_B.DataTypeConversion_f0[2];

    L4_MABX_B.Data[starting_index + 1] = L4_MABX_B.DataTypeConversion_f0[3];

    L4_MABX_B.Data[starting_index + 2] = L4_MABX_B.DataTypeConversion_f0[4];

    L4_MABX_B.Data[starting_index + 3] = L4_MABX_B.DataTypeConversion_f0[5];

    L4_MABX_B.Data[starting_index + 4] = L4_MABX_B.DataTypeConversion_f0[6];

    L4_MABX_B.Data[starting_index + 5] = L4_MABX_B.DataTypeConversion_f0[7];



    /* '<S658>:1:13' */

    L4_MABX_B.RX_status_bk = (L4_MABX_B.DataTypeConversion_f0[0] ==

      L4_MABX_B.SPN2568_TotalNumberOfPackets);



    /* End of MATLAB Function: '<S654>/serialize_tpdt' */



    /* Outputs for Enabled SubSystem: '<S654>/Decode' incorporates:

     *  EnablePort: '<S657>/Enable'

     */

    if (L4_MABX_B.RX_status_bk) {

      /* Inport: '<S657>/Inport' */

      for (i = 0; i < 17; i++) {

        L4_MABX_B.Inport[i] = L4_MABX_B.Data[i];

      }



      /* End of Inport: '<S657>/Inport' */



      /* Inport: '<S657>/timeStamp' */

      L4_MABX_B.timeStamp = GLB_Absolute_Timestamp;



      /* UnitDelay: '<S657>/Unit_Delay' */

      L4_MABX_B.Unit_Delay_m = L4_MABX_DW.Unit_Delay_DSTATE_d;



      /* Sum: '<S657>/Subtract' */

      L4_MABX_B.Subtract_j3 = (real32_T)(L4_MABX_B.timeStamp -

        L4_MABX_B.Unit_Delay_m);

    }



    /* End of Outputs for SubSystem: '<S654>/Decode' */

  }



  /* End of Outputs for SubSystem: '<S465>/CAN_RX_VI_00' */



  /* DataTypeConversion: '<S655>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_jo = L4_MABX_B.Inport[0];



  /* DataTypeConversion: '<S655>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_aq = L4_MABX_B.Inport[1];



  /* DataTypeConversion: '<S655>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_gd = L4_MABX_B.Inport[2];



  /* DataTypeConversion: '<S655>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_g = L4_MABX_B.Inport[3];



  /* DataTypeConversion: '<S655>/Data Type Conversion4' */

  L4_MABX_B.DataTypeConversion4_g4 = L4_MABX_B.Inport[4];



  /* DataTypeConversion: '<S655>/Data Type Conversion5' */

  L4_MABX_B.DataTypeConversion5_gv = L4_MABX_B.Inport[5];



  /* DataTypeConversion: '<S655>/Data Type Conversion6' */

  L4_MABX_B.DataTypeConversion6_e = L4_MABX_B.Inport[6];



  /* DataTypeConversion: '<S655>/Data Type Conversion7' */

  L4_MABX_B.DataTypeConversion7_m = L4_MABX_B.Inport[7];



  /* DataTypeConversion: '<S655>/Data Type Conversion8' */

  L4_MABX_B.DataTypeConversion8_aj = L4_MABX_B.Inport[8];



  /* DataTypeConversion: '<S655>/Data Type Conversion9' */

  L4_MABX_B.DataTypeConversion9_o = L4_MABX_B.Inport[9];



  /* DataTypeConversion: '<S655>/Data Type Conversion10' */

  L4_MABX_B.DataTypeConversion10_f5 = L4_MABX_B.Inport[10];



  /* DataTypeConversion: '<S655>/Data Type Conversion11' */

  L4_MABX_B.DataTypeConversion11_a = L4_MABX_B.Inport[11];



  /* DataTypeConversion: '<S655>/Data Type Conversion12' */

  L4_MABX_B.DataTypeConversion12 = L4_MABX_B.Inport[12];



  /* DataTypeConversion: '<S655>/Data Type Conversion14' */

  L4_MABX_B.DataTypeConversion14_k = L4_MABX_B.Inport[13];



  /* DataTypeConversion: '<S655>/Data Type Conversion13' */

  L4_MABX_B.DataTypeConversion13_h = L4_MABX_B.Inport[14];



  /* DataTypeConversion: '<S655>/Data Type Conversion15' */

  L4_MABX_B.DataTypeConversion15_o = L4_MABX_B.Inport[15];



  /* DataTypeConversion: '<S655>/Data Type Conversion16' */

  L4_MABX_B.DataTypeConversion16_o = L4_MABX_B.Inport[16];



  /* RelationalOperator: '<S655>/Relational Operator1' incorporates:

   *  Constant: '<S655>/TRUCK_1571_VIN_CPV'

   */

  L4_MABX_B.RelationalOperator1_d[0] = (L4_MABX_P.TRUCK_1571_VIN_CPV_Value[0] !=

    L4_MABX_B.DataTypeConversion_jo);

  L4_MABX_B.RelationalOperator1_d[1] = (L4_MABX_P.TRUCK_1571_VIN_CPV_Value[1] !=

    L4_MABX_B.DataTypeConversion1_aq);

  L4_MABX_B.RelationalOperator1_d[2] = (L4_MABX_P.TRUCK_1571_VIN_CPV_Value[2] !=

    L4_MABX_B.DataTypeConversion2_gd);

  L4_MABX_B.RelationalOperator1_d[3] = (L4_MABX_P.TRUCK_1571_VIN_CPV_Value[3] !=

    L4_MABX_B.DataTypeConversion3_g);

  L4_MABX_B.RelationalOperator1_d[4] = (L4_MABX_P.TRUCK_1571_VIN_CPV_Value[4] !=

    L4_MABX_B.DataTypeConversion4_g4);

  L4_MABX_B.RelationalOperator1_d[5] = (L4_MABX_P.TRUCK_1571_VIN_CPV_Value[5] !=

    L4_MABX_B.DataTypeConversion5_gv);

  L4_MABX_B.RelationalOperator1_d[6] = (L4_MABX_P.TRUCK_1571_VIN_CPV_Value[6] !=

    L4_MABX_B.DataTypeConversion6_e);

  L4_MABX_B.RelationalOperator1_d[7] = (L4_MABX_P.TRUCK_1571_VIN_CPV_Value[7] !=

    L4_MABX_B.DataTypeConversion7_m);

  L4_MABX_B.RelationalOperator1_d[8] = (L4_MABX_P.TRUCK_1571_VIN_CPV_Value[8] !=

    L4_MABX_B.DataTypeConversion8_aj);

  L4_MABX_B.RelationalOperator1_d[9] = (L4_MABX_P.TRUCK_1571_VIN_CPV_Value[9] !=

    L4_MABX_B.DataTypeConversion9_o);

  L4_MABX_B.RelationalOperator1_d[10] = (L4_MABX_P.TRUCK_1571_VIN_CPV_Value[10]

    != L4_MABX_B.DataTypeConversion10_f5);

  L4_MABX_B.RelationalOperator1_d[11] = (L4_MABX_P.TRUCK_1571_VIN_CPV_Value[11]

    != L4_MABX_B.DataTypeConversion11_a);

  L4_MABX_B.RelationalOperator1_d[12] = (L4_MABX_P.TRUCK_1571_VIN_CPV_Value[12]

    != L4_MABX_B.DataTypeConversion12);

  L4_MABX_B.RelationalOperator1_d[13] = (L4_MABX_P.TRUCK_1571_VIN_CPV_Value[13]

    != L4_MABX_B.DataTypeConversion14_k);

  L4_MABX_B.RelationalOperator1_d[14] = (L4_MABX_P.TRUCK_1571_VIN_CPV_Value[14]

    != L4_MABX_B.DataTypeConversion13_h);

  L4_MABX_B.RelationalOperator1_d[15] = (L4_MABX_P.TRUCK_1571_VIN_CPV_Value[15]

    != L4_MABX_B.DataTypeConversion15_o);

  L4_MABX_B.RelationalOperator1_d[16] = (L4_MABX_P.TRUCK_1571_VIN_CPV_Value[16]

    != L4_MABX_B.DataTypeConversion16_o);



  /* Sum: '<S655>/Add' */

  tmp = 0U;

  for (i = 0; i < 17; i++) {

    tmp += L4_MABX_B.RelationalOperator1_d[i];

  }



  L4_MABX_B.Add_au = (uint8_T)tmp;



  /* End of Sum: '<S655>/Add' */



  /* RelationalOperator: '<S659>/Compare' incorporates:

   *  Constant: '<S659>/Constant'

   */

  L4_MABX_B.Compare_i = (L4_MABX_B.Add_au == L4_MABX_P.Constant_Value_p04);



  /* Logic: '<S655>/Logical Operator' */

  L4_MABX_B.LogicalOperator_o = (L4_MABX_B.Unit_Delay3 && L4_MABX_B.Compare_i);



  /* UnitDelay: '<S655>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_mm = L4_MABX_DW.Unit_Delay_DSTATE_h1;



  /* Logic: '<S661>/Logical Operator3' */

  L4_MABX_B.LogicalOperator3_l = !L4_MABX_B.Unit_Delay_mm;



  /* UnitDelay: '<S661>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_iz = L4_MABX_DW.Unit_Delay_DSTATE_fr;



  /* Logic: '<S661>/Logical Operator' */

  L4_MABX_B.LogicalOperator_b = (L4_MABX_B.LogicalOperator3_l &&

    L4_MABX_B.Unit_Delay_iz);



  /* Logic: '<S661>/Logical Operator1' */

  L4_MABX_B.LogicalOperator1_c = (L4_MABX_B.LogicalOperator_o ||

    L4_MABX_B.LogicalOperator_b);



  /* Outputs for Enabled SubSystem: '<S636>/SSI2_031' incorporates:

   *  EnablePort: '<S637>/Enable'

   */

  /* Constant: '<S456>/Constant' */

  if (L4_MABX_P.Constant_Value_ov > 0.0) {

    /* S-Function (rti_commonblock): '<S637>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "SSI2_03" Id:217065731 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCF02903].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCF02903].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o8_h = 1.0;

        L4_MABX_B.SFunction1_o9_i = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCF02903].timestamp;

        L4_MABX_B.SFunction1_o10_ha = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCF02903].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCF02903].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "PitchAngleExRange" (0|24, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[1];

            CAN_Sgn.SgnBytes.Byte2 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x00FFFFFF;

            L4_MABX_B.SFunction1_o1_fk = -250 + ( 3.0517578125E-5 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) ) );



            /* ...... "RollAngleExRange" (24|24, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[4];

            CAN_Sgn.SgnBytes.Byte2 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x00FFFFFF;

            L4_MABX_B.SFunction1_o2_pq = -250 + ( 3.0517578125E-5 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) ) );



            /* ...... "PitchAngleExRangeCompensation" (48|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o3_eq = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "PitchAngleExRangeFigureOfMerit" (50|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o4_be = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "RollAngleExRangeCompensation" (52|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o5_fy = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "RollAngleExRangeFigureOfMerit" (54|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o6_l = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "RllAndPtchExRngMsurementLatency" (56|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o7_p = 0.5 * ( ((real_T) CAN_Sgn.UnsignedSgn) );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o8_h = 0.0;

      }

    }

  }



  /* End of Constant: '<S456>/Constant' */

  /* End of Outputs for SubSystem: '<S636>/SSI2_031' */



  /* DataTypeConversion: '<S636>/Data Type Conversion1' */

  L4_MABX_B.PitchAngleExRange = L4_MABX_B.SFunction1_o1_fk;



  /* Outputs for Enabled SubSystem: '<S627>/PX2_LanePosEst' incorporates:

   *  EnablePort: '<S630>/Enable'

   */

  /* Constant: '<S453>/Constant' */

  if (L4_MABX_P.Constant_Value_kr) {

    /* S-Function (rti_commonblock): '<S630>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "PX2_LanePosEst" Id:769 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x301].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x301].timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o5_b = 1.0;

        L4_MABX_B.SFunction1_o6_kc = (real_T)

          can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x301].timestamp;

        L4_MABX_B.SFunction1_o7_d = (real_T)

          can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x301].deltatime;

        CAN_Msg = can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x301].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "PX2_LanePosEstAngle" (0|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[1];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o1_oq = 0.01 * ( ((real_T) CAN_Sgn.SignedSgn) );



            /* ...... "PX2_LanePosEstNumPoints" (16|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o2_mr = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "PX2_LanePosEstPosition" (24|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[4];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o3_ev = 0.001 * ( ((real_T) CAN_Sgn.SignedSgn) );



            /* ...... "PX2_LanePosEstNumLanes" (40|4, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x0000000F;

            L4_MABX_B.SFunction1_o4_aw = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o5_b = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S627>/PX2_LanePosEst' */



  /* Outputs for Enabled SubSystem: '<S634>/Bendix_Prop2C2_Status_30' incorporates:

   *  EnablePort: '<S635>/Enable'

   */

  /* Constant: '<S455>/Constant' */

  if (L4_MABX_P.Constant_Value_i3 > 0.0) {

    /* S-Function (rti_commonblock): '<S635>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "Prop2C2_Status_30" Id:419382064 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M2_C1_XTD[CANTP1_M2_C1_RXSRVC_XTD_0x18FF4330].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M2_C1_XTD[CANTP1_M2_C1_RXSRVC_XTD_0x18FF4330].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o11_d = 1.0;

        L4_MABX_B.SFunction1_o12_k = (real_T)

          can_type1_M2_C1_XTD[CANTP1_M2_C1_RXSRVC_XTD_0x18FF4330].timestamp;

        L4_MABX_B.SFunction1_o13_g = (real_T)

          can_type1_M2_C1_XTD[CANTP1_M2_C1_RXSRVC_XTD_0x18FF4330].deltatime;

        CAN_Msg = can_type1_M2_C1_XTD[CANTP1_M2_C1_RXSRVC_XTD_0x18FF4330].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "PressureP4" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_ko = 80 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "PressureP1" (8|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o2_jn = 80 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "PressureP21" (16|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o3_hm = 80 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "PressureP22" (24|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o4_hk = 80 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "PressureP42" (32|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o5_fg = 80 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "XPR1ControlStatus" (40|4, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x0000000F;

            L4_MABX_B.SFunction1_o6_a = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "XPR2ControlStatus" (44|4, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x0000000F;

            L4_MABX_B.SFunction1_o7_a = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "XPR3ControlStatus" (48|4, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x0000000F;

            L4_MABX_B.SFunction1_o8_b = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "XPRErrorState" (56|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o9_l = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "XPRControlMode" (58|4, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x0000000F;

            L4_MABX_B.SFunction1_o10_d = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o11_d = 0.0;

      }

    }

  }



  /* End of Constant: '<S455>/Constant' */

  /* End of Outputs for SubSystem: '<S634>/Bendix_Prop2C2_Status_30' */



  /* DataTypeConversion: '<S634>/Data Type Conversion15' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o10_d;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion15_m = starting_index;



  /* End of DataTypeConversion: '<S634>/Data Type Conversion15' */



  /* DataTypeConversion: '<S634>/Data Type Conversion5' */

  L4_MABX_B.XPRControlMode = (ENUM_XPR_CONTROL_MODE_T)

    safe_cast_to_ENUM_XPR_CONTROL_M(L4_MABX_B.DataTypeConversion15_m);



  /* DataTypeConversion: '<S634>/Data Type Conversion4' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o9_l;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion4_lm = starting_index;



  /* End of DataTypeConversion: '<S634>/Data Type Conversion4' */



  /* DataTypeConversion: '<S634>/Data Type Conversion14' */

  L4_MABX_B.XPRErrorState = (ENUM_XPR_ERROR_STATE_T)

    safe_cast_to_ENUM_XPR_ERROR_STA(L4_MABX_B.DataTypeConversion4_lm);



  /* DataTypeConversion: '<S634>/Data Type Conversion7' */

  L4_MABX_B.PressureP1 = L4_MABX_B.SFunction1_o2_jn;



  /* DataTypeConversion: '<S634>/Data Type Conversion6' */

  L4_MABX_B.PressureP4 = L4_MABX_B.SFunction1_o1_ko;



  /* DataTypeConversion: '<S634>/Data Type Conversion11' */

  L4_MABX_B.PressureP21 = L4_MABX_B.SFunction1_o3_hm;



  /* DataTypeConversion: '<S634>/Data Type Conversion12' */

  L4_MABX_B.PressureP22 = L4_MABX_B.SFunction1_o4_hk;



  /* DataTypeConversion: '<S634>/Data Type Conversion13' */

  L4_MABX_B.PressureP42 = L4_MABX_B.SFunction1_o5_fg;



  /* RelationalOperator: '<S666>/Operator' incorporates:

   *  Constant: '<S472>/Constant3'

   *  Constant: '<S664>/Constant1'

   */

  L4_MABX_B.Operator_nc = (PROPB_REAX_CHANNEL_APV ==

    L4_MABX_P.Constant1_Value_bk);



  /* Outputs for Enabled SubSystem: '<S584>/PropB_REAX_2_13' incorporates:

   *  EnablePort: '<S586>/Enable'

   */

  if (L4_MABX_B.Operator_nc) {

    /* S-Function (rti_commonblock): '<S586>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "PropB_REAX_2_13" Id:419426323 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FFF013].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FFF013].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o3_pv = 1.0;

        L4_MABX_B.SFunction1_o4_c = (real_T)

          can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FFF013].timestamp;

        L4_MABX_B.SFunction1_o5_ni = (real_T)

          can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FFF013].deltatime;

        CAN_Msg = can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FFF013].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "PropB_REAX_2_ActualHandwheelPos" (0|32, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[1];

            CAN_Sgn.SgnBytes.Byte2 = CAN_Msg[2];

            CAN_Sgn.SgnBytes.Byte3 = CAN_Msg[3];

            L4_MABX_B.SFunction1_o1_cs = 0.0439453125 * ( ((real_T)

              CAN_Sgn.SignedSgn) );



            /* ...... "PropB_REAX_2_EchoedStrWhlPos" (32|32, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

            CAN_Sgn.SgnBytes.Byte2 = CAN_Msg[6];

            CAN_Sgn.SgnBytes.Byte3 = CAN_Msg[7];

            L4_MABX_B.SFunction1_o2_jnu = 0.0439453125 * ( ((real_T)

              CAN_Sgn.SignedSgn) );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o3_pv = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S584>/PropB_REAX_2_13' */



  /* RelationalOperator: '<S665>/Operator' incorporates:

   *  Constant: '<S472>/Constant3'

   *  Constant: '<S664>/Constant'

   */

  L4_MABX_B.Operator_cqv = (PROPB_REAX_CHANNEL_APV ==

    L4_MABX_P.Constant_Value_prb);



  /* RelationalOperator: '<S667>/Operator' incorporates:

   *  Constant: '<S472>/Constant3'

   *  Constant: '<S664>/Constant2'

   */

  L4_MABX_B.Operator_j2 = (PROPB_REAX_CHANNEL_APV ==

    L4_MABX_P.Constant2_Value_bj);



  /* RelationalOperator: '<S668>/Operator' incorporates:

   *  Constant: '<S472>/Constant3'

   *  Constant: '<S664>/Constant3'

   */

  L4_MABX_B.Operator_af = (PROPB_REAX_CHANNEL_APV ==

    L4_MABX_P.Constant3_Value_lj);



  /* RelationalOperator: '<S669>/Operator' incorporates:

   *  Constant: '<S472>/Constant3'

   *  Constant: '<S664>/Constant4'

   */

  L4_MABX_B.Operator_ey = (PROPB_REAX_CHANNEL_APV ==

    L4_MABX_P.Constant4_Value_j1);



  /* RelationalOperator: '<S670>/Operator' incorporates:

   *  Constant: '<S472>/Constant3'

   *  Constant: '<S664>/Constant5'

   */

  L4_MABX_B.Operator_j4 = (PROPB_REAX_CHANNEL_APV ==

    L4_MABX_P.Constant5_Value_bs);



  /* Logic: '<S472>/OR' */

  L4_MABX_B.EnablePropB_ReAX_CAN6 = (L4_MABX_B.Operator_cqv ||

    L4_MABX_B.Operator_j2 || L4_MABX_B.Operator_af || L4_MABX_B.Operator_ey ||

    L4_MABX_B.Operator_j4);



  /* Outputs for Enabled SubSystem: '<S585>/PropB_REAX_2_13' incorporates:

   *  EnablePort: '<S587>/Enable'

   */

  if (L4_MABX_B.EnablePropB_ReAX_CAN6) {

    /* S-Function (rti_commonblock): '<S587>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "PropB_REAX_2_13" Id:486535187 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M3_C2_XTD[CANTP1_M3_C2_RXSRVC_XTD_0x1CFFF013].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M3_C2_XTD[CANTP1_M3_C2_RXSRVC_XTD_0x1CFFF013].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o3_l1 = 1.0;

        L4_MABX_B.SFunction1_o4_k1 = (real_T)

          can_type1_M3_C2_XTD[CANTP1_M3_C2_RXSRVC_XTD_0x1CFFF013].timestamp;

        L4_MABX_B.SFunction1_o5_j = (real_T)

          can_type1_M3_C2_XTD[CANTP1_M3_C2_RXSRVC_XTD_0x1CFFF013].deltatime;

        CAN_Msg = can_type1_M3_C2_XTD[CANTP1_M3_C2_RXSRVC_XTD_0x1CFFF013].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "PropB_REAX_2_ActualHandwheelPos" (0|32, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[1];

            CAN_Sgn.SgnBytes.Byte2 = CAN_Msg[2];

            CAN_Sgn.SgnBytes.Byte3 = CAN_Msg[3];

            L4_MABX_B.SFunction1_o1_ph = 0.0439453125 * ( ((real_T)

              CAN_Sgn.SignedSgn) );



            /* ...... "PropB_REAX_2_EchoedStrWhlPos" (32|32, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

            CAN_Sgn.SgnBytes.Byte2 = CAN_Msg[6];

            CAN_Sgn.SgnBytes.Byte3 = CAN_Msg[7];

            L4_MABX_B.SFunction1_o2_g5 = 0.0439453125 * ( ((real_T)

              CAN_Sgn.SignedSgn) );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o3_l1 = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S585>/PropB_REAX_2_13' */



  /* Switch: '<S449>/Switch' */

  if (L4_MABX_B.Operator_nc) {

    ReAX_ActualHandwheelPos = L4_MABX_B.SFunction1_o1_cs;

  } else {

    ReAX_ActualHandwheelPos = L4_MABX_B.SFunction1_o1_ph;

  }



  /* S-Function (dsa_tcpip_setup_sfcn): '<S405>/dsa_tcpip_setup' */



  /* Level2 S-Function Block: '<S405>/dsa_tcpip_setup' (dsa_tcpip_setup_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[3];

    ssSetOutputPortSignal(rts, 0, &EthernetLinkStatus);

    sfcnOutputs(rts,0);

  }



  /* Constant: '<S3>/Enable' */

  L4_MABX_B.Enable = L4_MABX_P.Enable_Value;



  /* DiscretePulseGenerator: '<S404>/Heartbeat' */

  L4_MABX_B.Heartbeat = (L4_MABX_DW.clockTickCounter < L4_MABX_P.Heartbeat_Duty)

    && (L4_MABX_DW.clockTickCounter >= 0) ? L4_MABX_P.Heartbeat_Amp : 0.0;

  if (L4_MABX_DW.clockTickCounter >= L4_MABX_P.Heartbeat_Period - 1.0) {

    L4_MABX_DW.clockTickCounter = 0;

  } else {

    L4_MABX_DW.clockTickCounter++;

  }



  /* End of DiscretePulseGenerator: '<S404>/Heartbeat' */



  /* DataTypeConversion: '<S404>/Cast To Boolean' */

  MABX_Heartbeat = (L4_MABX_B.Heartbeat != 0.0);



  /* UnitDelay: '<S3>/Unit_Delay' */

  L4_MABX_B.EStop_j = L4_MABX_DW.Unit_Delay_80_DSTATE;

  L4_MABX_B.EnableSW = L4_MABX_DW.Unit_Delay_81_DSTATE;

  L4_MABX_B.EngageReq = L4_MABX_DW.Unit_Delay_48_DSTATE;

  L4_MABX_B.LogPB = L4_MABX_DW.Unit_Delay_83_DSTATE;

  L4_MABX_B.AutonomousEnabled = L4_MABX_DW.Unit_Delay_45_DSTATE;

  L4_MABX_B.MABX_Mode_h = L4_MABX_DW.Unit_Delay_47_DSTATE;

  L4_MABX_B.BrakeSW_j = L4_MABX_DW.Unit_Delay_84_DSTATE;



  /* BusCreator: '<S404>/Bus Creator' */

  L4_MABX_B.BusCreator.Heartbeat = MABX_Heartbeat;

  L4_MABX_B.BusCreator.EStop = L4_MABX_B.EStop_j;

  L4_MABX_B.BusCreator.EnableSW = L4_MABX_B.EnableSW;

  L4_MABX_B.BusCreator.EngageReq = L4_MABX_B.EngageReq;

  L4_MABX_B.BusCreator.LogEventPB = L4_MABX_B.LogPB;

  L4_MABX_B.BusCreator.AutonomousEnabled = L4_MABX_B.AutonomousEnabled;

  L4_MABX_B.BusCreator.MABX_Mode = L4_MABX_B.MABX_Mode_h;

  L4_MABX_B.BusCreator.BrakeSW = L4_MABX_B.BrakeSW_j;



  /* S-Function (dsa_gen_tx_RTMapsEncode_sfun): '<S413>/Encoder' */

  Update_Tx_RTMapsEncode((RTMapsTX*)&L4_MABX_B.BusCreator,

    &L4_MABX_B.Encoder_o1[0], &L4_MABX_B.Encoder_o2);



  /* S-Function (dsa_tcpip_udp_sfcn): '<S406>/TCPIP_Com' */



  /* Level2 S-Function Block: '<S406>/TCPIP_Com' (dsa_tcpip_udp_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[4];

    sfcnOutputs(rts,0);

  }



  /* DataTypeConversion: '<S403>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_aq = L4_MABX_B.TCPIP_Com_o2;



  /* S-Function (dsa_gen_rx_RTMapsDecode_sfun): '<S410>/Decoder' */

  Update_Rx_RTMapsDecode((uint8_T*)&L4_MABX_B.TCPIP_Com_o3[0],

    L4_MABX_B.DataTypeConversion_aq, L4_MABX_B.TCPIP_Com_o1[2],

    &L4_MABX_B.Decoder_o1, &L4_MABX_B.Decoder_o2, &L4_MABX_B.Decoder_o3);



  /* RelationalOperator: '<S412>/Compare' incorporates:

   *  Constant: '<S412>/Constant'

   */

  L4_MABX_B.Compare_c = ((int32_T)L4_MABX_B.Decoder_o1.Heartbeat > (int32_T)

    L4_MABX_P.Constant_Value_ap);



  /* UnitDelay: '<S411>/Delay Input1' */

  L4_MABX_B.Uk1_f = L4_MABX_DW.DelayInput1_DSTATE_n;



  /* RelationalOperator: '<S411>/FixPt Relational Operator' */

  L4_MABX_B.FixPtRelationalOperator_i = ((int32_T)L4_MABX_B.Compare_c > (int32_T)

    L4_MABX_B.Uk1_f);



  /* UnitDelay: '<S409>/Unit Delay' */

  L4_MABX_B.UnitDelay_f = L4_MABX_DW.UnitDelay_DSTATE_k;



  /* Switch: '<S409>/Switch' incorporates:

   *  Constant: '<S409>/Constant1'

   */

  if (L4_MABX_B.FixPtRelationalOperator_i) {

    L4_MABX_B.Count = L4_MABX_P.Constant1_Value_e;

  } else {

    /* Sum: '<S409>/Sum' incorporates:

     *  Constant: '<S409>/Constant'

     */

    L4_MABX_B.Sum_l = L4_MABX_P.Constant_Value_l + L4_MABX_B.UnitDelay_f;

    L4_MABX_B.Count = L4_MABX_B.Sum_l;

  }



  /* End of Switch: '<S409>/Switch' */



  /* Switch: '<S409>/Switch1' incorporates:

   *  Constant: '<S409>/Constant2'

   *  Constant: '<S409>/Constant3'

   */

  if (L4_MABX_B.Count > L4_MABX_P.Switch1_Threshold) {

    Heartbeat_Ok = L4_MABX_P.Constant2_Value_e;

  } else {

    Heartbeat_Ok = L4_MABX_P.Constant3_Value_f;

  }



  /* End of Switch: '<S409>/Switch1' */



  /* Logic: '<S403>/AND' */

  RTMapsOk = ((EthernetLinkStatus != 0.0) && Heartbeat_Ok);



  /* Switch: '<S403>/Switch9' incorporates:

   *  Constant: '<S403>/Failure'

   */

  if (RTMapsOk) {

    /* Gain: '<S403>/for_logging7' */

    L4_MABX_B.SupervisorMode_b = (int8_T)(((uint32_T)L4_MABX_P.for_logging7_Gain

      * L4_MABX_B.Decoder_o1.SupervisorMode) >> 7);

    SupervisorMode = (uint8_T)L4_MABX_B.SupervisorMode_b;

  } else {

    SupervisorMode = L4_MABX_P.Failure_Value_k;

  }



  /* End of Switch: '<S403>/Switch9' */



  /* RelationalOperator: '<S408>/Operator' incorporates:

   *  Constant: '<S403>/Supervisor_Autonomous_Mode'

   */

  L4_MABX_B.Operator_m1 = (L4_MABX_P.Supervisor_Autonomous_Mode_Valu ==

    SupervisorMode);



  /* Logic: '<S403>/AND1' */

  L4_MABX_B.SystemsOk = (RTMapsOk && L4_MABX_B.Operator_m1);



  /* Switch: '<S403>/Switch' incorporates:

   *  Constant: '<S403>/No Data'

   *  Switch: '<S403>/Switch1'

   *  Switch: '<S403>/Switch3'

   *  Switch: '<S403>/Switch4'

   *  Switch: '<S403>/Switch5'

   */

  if (RTMapsOk) {

    /* Gain: '<S403>/for_logging' */

    L4_MABX_B.for_logging = L4_MABX_P.for_logging_Gain *

      L4_MABX_B.Decoder_o1.CurrentAzimuth;

    CurrentAzimuth_rad = L4_MABX_B.for_logging;



    /* Gain: '<S403>/for_logging1' */

    L4_MABX_B.for_logging1 = L4_MABX_P.for_logging1_Gain *

      L4_MABX_B.Decoder_o1.TargetAzimuth;

    TargetAzimuth_rad = L4_MABX_B.for_logging1;



    /* Gain: '<S403>/m//s_to_km//h_2' */

    L4_MABX_B.ms_to_kmh_2 = L4_MABX_P.ms_to_kmh_2_Gain *

      L4_MABX_B.Decoder_o1.TargetVelocity;

    TargetVelocity_kph = L4_MABX_B.ms_to_kmh_2;



    /* Gain: '<S403>/for_logging2' */

    L4_MABX_B.for_logging2 = L4_MABX_P.for_logging2_Gain *

      L4_MABX_B.Decoder_o1.Curvature;

    Curvature = L4_MABX_B.for_logging2;



    /* Gain: '<S403>/for_logging3' */

    L4_MABX_B.for_logging3 = L4_MABX_P.for_logging3_Gain *

      L4_MABX_B.Decoder_o1.CrosstrackError;

    CrosstrackError = L4_MABX_B.for_logging3;

  } else {

    CurrentAzimuth_rad = L4_MABX_P.NoData_Value;

    TargetAzimuth_rad = L4_MABX_P.NoData_Value;

    TargetVelocity_kph = L4_MABX_P.NoData_Value;

    Curvature = L4_MABX_P.NoData_Value;

    CrosstrackError = L4_MABX_P.NoData_Value;

  }



  /* End of Switch: '<S403>/Switch' */



  /* Outputs for Atomic SubSystem: '<S65>/Task_10ms' */

  /* UnitDelay: '<S97>/Unit Delay1' */

  L4_MABX_B.UnitDelay1_f = L4_MABX_DW.UnitDelay1_DSTATE_m;



  /* UnitDelay: '<S76>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_nh = L4_MABX_DW.Unit_Delay_DSTATE_fv;



  /* RelationalOperator: '<S100>/Compare' incorporates:

   *  Constant: '<S100>/Constant'

   */

  L4_MABX_B.Compare_jp = ((int32_T)L4_MABX_B.Unit_Delay_nh <= (int32_T)

    L4_MABX_P.Constant_Value_io);



  /* UnitDelay: '<S98>/Delay Input1' */

  L4_MABX_B.Uk1_d = L4_MABX_DW.DelayInput1_DSTATE_d;



  /* RelationalOperator: '<S98>/FixPt Relational Operator' */

  L4_MABX_B.FixPtRelationalOperator_o = ((int32_T)L4_MABX_B.Compare_jp >

    (int32_T)L4_MABX_B.Uk1_d);



  /* UnitDelay: '<S97>/Unit Delay' */

  L4_MABX_B.UnitDelay_i3 = L4_MABX_DW.UnitDelay_DSTATE_b1;



  /* Logic: '<S97>/OR' */

  L4_MABX_B.OR_e = (L4_MABX_B.FixPtRelationalOperator_o ||

                    L4_MABX_B.UnitDelay_i3);



  /* Switch: '<S97>/Switch' incorporates:

   *  Constant: '<S97>/Constant0'

   */

  if (L4_MABX_B.OR_e) {

    /* Sum: '<S97>/Sum' incorporates:

     *  Constant: '<S97>/Constant1'

     */

    L4_MABX_B.Sum_gp = L4_MABX_B.UnitDelay1_f + L4_MABX_P.Constant1_Value;

    L4_MABX_B.Switch_a = L4_MABX_B.Sum_gp;

  } else {

    L4_MABX_B.Switch_a = L4_MABX_P.Constant0_Value;

  }



  /* End of Switch: '<S97>/Switch' */



  /* RelationalOperator: '<S99>/Compare' incorporates:

   *  Constant: '<S99>/Constant'

   */

  L4_MABX_B.Compare_fh = (L4_MABX_B.Switch_a > L4_MABX_P.Constant_Value_hq);



  /* Gain: '<S97>/Gain' incorporates:

   *  Constant: '<S95>/2000ms Delay'

   */

  L4_MABX_B.Gain_co = (uint32_T)L4_MABX_P.Gain_Gain_b *

    L4_MABX_P.u000msDelay_Value;



  /* RelationalOperator: '<S97>/LessThanOrEqual' */

  L4_MABX_B.LessThanOrEqual_g = (L4_MABX_B.Switch_a <= (real_T)L4_MABX_B.Gain_co

    * 1.9073486328125E-6);



  /* Logic: '<S97>/AND' */

  L4_MABX_B.AND_f = (L4_MABX_B.Compare_fh && L4_MABX_B.LessThanOrEqual_g);



  /* Logic: '<S95>/NOT1' */

  L4_MABX_B.NOT1_h = !L4_MABX_B.AND_f;



  /* Logic: '<S76>/AND1' */

  L4_MABX_B.AND1_i = (EStop && EnableSw && BrakeSW && L4_MABX_B.NOT1_h);



  /* Sum: '<S96>/Subtract' */

  L4_MABX_B.Subtract_a = TargetVelocity_kph - L4_MABX_B.SFunction1_o1_gd;



  /* RelationalOperator: '<S101>/Compare' incorporates:

   *  Constant: '<S101>/Constant'

   */

  L4_MABX_B.Compare_is = (L4_MABX_B.Subtract_a >=

    L4_MABX_P.CompareToConstant_const_a);



  /* Logic: '<S96>/AND' */

  L4_MABX_B.AND_a = (L4_MABX_B.AND1_i && EngagePB && L4_MABX_B.Compare_is);



  /* Logic: '<S76>/OR' */

  L4_MABX_B.OR_l = (L4_MABX_B.Unit_Delay_nh || L4_MABX_B.AND_a);



  /* Logic: '<S76>/AND' */

  L4_MABX_B.AutonomousEnabled_d = (L4_MABX_B.SystemsOk && L4_MABX_B.AND1_i &&

    L4_MABX_B.OR_l);



  /* Logic: '<S83>/Logical Operator' */

  L4_MABX_B.LogicalOperator_d = !L4_MABX_B.AutonomousEnabled_d;



  /* Outputs for Atomic SubSystem: '<S83>/If_Then_Else' */



  /* Constant: '<S83>/APTC_PEDAL_POSITION_OVR_APV' incorporates:

   *  Constant: '<S83>/APTC_DESIRED_PEDAL_POSITION_APV'

   */

  L4_MABX_If_Then_Else(L4_MABX_P.APTC_PEDAL_POSITION_OVR_APV_Val,

                       L4_MABX_P.APTC_DESIRED_PEDAL_POSITION_APV,

                       Pedal_pwm_position, &L4_MABX_B.If_Then_Else_oy);



  /* End of Outputs for SubSystem: '<S83>/If_Then_Else' */



  /* DataTypeConversion: '<S83>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_ht = L4_MABX_B.SFunction1_o5_nl;



  /* Lookup_n-D: '<S83>/2-D Lookup Table' */

  L4_MABX_B.uDLookupTable = look2_binlcapw(L4_MABX_B.If_Then_Else_oy.Switch,

    L4_MABX_B.DataTypeConversion1_ht, APTC_TRQ_PED_TRQ_POS_STEP_MPV,

    APTC_TRQ_PED_TRQ_ESPD_STEP_MPV, APTC_TRQ_PED_TRQ_DATA_MPV,

    L4_MABX_P.uDLookupTable_maxIndex, 8U);



  /* DataTypeConversion: '<S77>/Data Type Conversion5' */

  L4_MABX_B.DataTypeConversion5_o = L4_MABX_B.SFunction1_o1_gd;



  /* RateTransition: '<S81>/TmpRTBAtSignal Conversion1Inport1' */

  if (L4_MABX_M->Timing.RateInteraction.TID0_1 == 1) {

    L4_MABX_B.distanceSpdTarget_e = L4_MABX_DW.TmpRTBAtSignalConversion1Inport;

  }



  /* MultiPortSwitch: '<S81>/Multiport Switch' incorporates:

   *  Constant: '<S81>/LONG_SPEED_SRC_SELECTOR_APV'

   */

  switch (LONG_SPEED_SRC_SELECTOR_APV) {

   case ENUM_LONG_SPEED_DEMAND_SOURCE_T_GPS_PATH:

    /* SignalConversion: '<S81>/Signal Conversion1' */

    L4_MABX_B.Vehicle_speed_target_g = L4_MABX_B.distanceSpdTarget_e;

    L4_MABX_B.Vehicle_speed_target_o = L4_MABX_B.Vehicle_speed_target_g;

    break;



   case ENUM_LONG_SPEED_DEMAND_SOURCE_T_OVERRIDE:

    /* SignalConversion: '<S81>/Signal Conversion4' incorporates:

     *  Constant: '<S81>/VSPD_TARGET_KPH_APV'

     */

    L4_MABX_B.Vehicle_speed_target_o5 = VSPD_TARGET_KPH_APV;

    L4_MABX_B.Vehicle_speed_target_o = L4_MABX_B.Vehicle_speed_target_o5;

    break;



   default:

    /* SignalConversion: '<S81>/Signal Conversion9' */

    L4_MABX_B.Vehicle_speed_target_k = TargetVelocity_kph;

    L4_MABX_B.Vehicle_speed_target_o = L4_MABX_B.Vehicle_speed_target_k;

    break;

  }



  /* SignalConversion: '<S81>/Signal Conversion16' */

  L4_MABX_B.VSPD_TARGET_KPH_APV_g = L4_MABX_B.Vehicle_speed_target_o;



  /* Saturate: '<S81>/Saturation9' incorporates:

   *  Constant: '<S81>/VSPD_HYST_KPH_APV'

   */

  DeltaTime = L4_MABX_P.VSPD_HYST_KPH_APV_Value;

  Time56 = L4_MABX_P.Saturation9_LowerSat;

  AccelerationAverage = L4_MABX_P.Saturation9_UpperSat;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.VSPD_HYST_KPH_APV_f = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.VSPD_HYST_KPH_APV_f = Time56;

  } else {

    L4_MABX_B.VSPD_HYST_KPH_APV_f = DeltaTime;

  }



  /* End of Saturate: '<S81>/Saturation9' */



  /* Sum: '<S109>/Add' */

  L4_MABX_B.Add_k = L4_MABX_B.VSPD_TARGET_KPH_APV_g +

    L4_MABX_B.VSPD_HYST_KPH_APV_f;



  /* RelationalOperator: '<S109>/Relational Operator' */

  L4_MABX_B.f_vspd_geq_than_target_plus_hys = (L4_MABX_B.DataTypeConversion5_o >=

    L4_MABX_B.Add_k);



  /* Saturate: '<S81>/Saturation1' incorporates:

   *  Constant: '<S81>/VSPD_BRAKE_STOP_THRESH_KPH_APV'

   */

  DeltaTime = L4_MABX_P.VSPD_BRAKE_STOP_THRESH_KPH_APV_;

  Time56 = L4_MABX_P.Saturation1_LowerSat;

  AccelerationAverage = L4_MABX_P.Saturation1_UpperSat;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.VSPD_BRAKE_STOP_THRESH_KPH_AP_b = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.VSPD_BRAKE_STOP_THRESH_KPH_AP_b = Time56;

  } else {

    L4_MABX_B.VSPD_BRAKE_STOP_THRESH_KPH_AP_b = DeltaTime;

  }



  /* End of Saturate: '<S81>/Saturation1' */



  /* RelationalOperator: '<S109>/Relational Operator1' */

  L4_MABX_B.f_target_is_stop_thresh = (L4_MABX_B.VSPD_BRAKE_STOP_THRESH_KPH_AP_b

    == L4_MABX_B.VSPD_TARGET_KPH_APV_g);



  /* RelationalOperator: '<S205>/Compare' incorporates:

   *  Constant: '<S205>/Constant'

   */

  L4_MABX_B.Compare_eu = (L4_MABX_B.VSPD_TARGET_KPH_APV_g ==

    L4_MABX_P.Constant_Value_k);



  /* RelationalOperator: '<S109>/Relational Operator2' */

  L4_MABX_B.RelationalOperator2_p = (L4_MABX_B.VSPD_HYST_KPH_APV_f >=

    L4_MABX_B.VSPD_TARGET_KPH_APV_g);



  /* RelationalOperator: '<S109>/Relational Operator3' */

  L4_MABX_B.RelationalOperator3 = (L4_MABX_B.VSPD_HYST_KPH_APV_f >=

    L4_MABX_B.DataTypeConversion5_o);



  /* Logic: '<S109>/Logical Operator' */

  L4_MABX_B.f_vspd_leq_than_hyst_and_target = (L4_MABX_B.RelationalOperator2_p &&

    L4_MABX_B.RelationalOperator3);



  /* Logic: '<S109>/Logical Operator1' */

  L4_MABX_B.LogicalOperator1_m = (L4_MABX_B.f_vspd_geq_than_target_plus_hys ||

    L4_MABX_B.f_target_is_stop_thresh || L4_MABX_B.Compare_eu ||

    L4_MABX_B.f_vspd_leq_than_hyst_and_target);



  /* DataTypeConversion: '<S77>/Data Type Conversion4' */

  L4_MABX_B.DataTypeConversion4_d5 = L4_MABX_B.AutonomousEnabled_d;



  /* Logic: '<S109>/Logical Operator2' */

  L4_MABX_B.F_Brake_control_active = (L4_MABX_B.LogicalOperator1_m &&

    L4_MABX_B.DataTypeConversion4_d5);



  /* DataTypeConversion: '<S79>/Data Type Conversion4' */

  L4_MABX_B.DataTypeConversion4_ib = L4_MABX_B.SFunction1_o1_gd;



  /* DataTypeConversion: '<S77>/Data Type Conversion1' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o8_fp;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion1_ba = starting_index;



  /* End of DataTypeConversion: '<S77>/Data Type Conversion1' */



  /* DataTypeConversion: '<S77>/Data Type Conversion3' */

  L4_MABX_B.BrkPedArbBrakeSwitch_c = (ENUM_J1939_SWITCH_T)

    L4_MABX_B.DataTypeConversion1_ba;



  /* DataTypeConversion: '<S209>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_cy = L4_MABX_B.BrkPedArbBrakeSwitch_c;



  /* RelationalOperator: '<S215>/Compare' incorporates:

   *  Constant: '<S215>/Constant'

   */

  L4_MABX_B.Compare_e5 = (L4_MABX_B.DataTypeConversion1_cy ==

    L4_MABX_P.CompareToConstant2_const);



  /* Logic: '<S209>/Logical Operator2' */

  L4_MABX_B.LogicalOperator2_n = !L4_MABX_B.Compare_e5;



  /* DataTypeConversion: '<S209>/Data Type Conversion5' */

  PositionFinalLimited = floor(L4_MABX_B.SFunction1_o4_nj);

  if (rtIsNaN(PositionFinalLimited) || rtIsInf(PositionFinalLimited)) {

    PositionFinalLimited = 0.0;

  } else {

    PositionFinalLimited = fmod(PositionFinalLimited, 256.0);

  }



  L4_MABX_B.DataTypeConversion5_pw = (uint8_T)(PositionFinalLimited < 0.0 ?

    (int32_T)(uint8_T)-(int8_T)(uint8_T)-PositionFinalLimited : (int32_T)

    (uint8_T)PositionFinalLimited);



  /* End of DataTypeConversion: '<S209>/Data Type Conversion5' */



  /* DataTypeConversion: '<S209>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_l = (ENUM_J1939_SWITCH_T)

    L4_MABX_B.DataTypeConversion5_pw;



  /* RelationalOperator: '<S213>/Compare' incorporates:

   *  Constant: '<S213>/Constant'

   */

  L4_MABX_B.Compare_ih = (L4_MABX_B.DataTypeConversion3_l ==

    L4_MABX_P.CompareToConstant_const_e);



  /* RelationalOperator: '<S214>/Compare' incorporates:

   *  Constant: '<S214>/Constant'

   */

  L4_MABX_B.Compare_exd = (L4_MABX_B.DataTypeConversion3_l ==

    L4_MABX_P.CompareToConstant1_const_j);



  /* Logic: '<S209>/BrakingActive2' */

  L4_MABX_B.BrakingActive2 = (L4_MABX_B.Compare_ih || L4_MABX_B.Compare_exd);



  /* Logic: '<S209>/BrakingActive1' */

  L4_MABX_B.f_brake_sw_off = (L4_MABX_B.LogicalOperator2_n &&

    L4_MABX_B.BrakingActive2);



  /* RelationalOperator: '<S216>/Compare' incorporates:

   *  Constant: '<S216>/Constant'

   */

  L4_MABX_B.Compare_ay = (L4_MABX_B.SPN524_TransSelectedGear >

    L4_MABX_P.Constant_Value_il);



  /* RelationalOperator: '<S217>/Compare' incorporates:

   *  Constant: '<S217>/Constant'

   */

  L4_MABX_B.Compare_os = (L4_MABX_B.SPN523_TransCurrentGear >

    L4_MABX_P.Constant_Value_f);



  /* Logic: '<S209>/Logical Operator1' */

  L4_MABX_B.f_brk_gov_inactive = !L4_MABX_B.F_Brake_control_active;



  /* Logic: '<S209>/Logical Operator' */

  L4_MABX_B.LogicalOperator_ke = (L4_MABX_B.AutonomousEnabled_d &&

    L4_MABX_B.f_brake_sw_off && L4_MABX_B.Compare_ay && L4_MABX_B.Compare_os &&

    L4_MABX_B.f_brk_gov_inactive);



  /* Outputs for Enabled SubSystem: '<S79>/Throttle_controller_gov' incorporates:

   *  EnablePort: '<S212>/Enable'

   */

  if (L4_MABX_B.LogicalOperator_ke) {

    if (!L4_MABX_DW.Throttle_controller_gov_MODE) {

      /* InitializeConditions for UnitDelay: '<S220>/Unit_Delay1' */

      L4_MABX_DW.Unit_Delay1_DSTATE_p1 =

        L4_MABX_P.Unit_Delay1_InitialCondition_o;



      /* InitializeConditions for UnitDelay: '<S220>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_lq = L4_MABX_P.Unit_Delay_InitialCondition_b2;



      /* InitializeConditions for UnitDelay: '<S247>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_be = L4_MABX_P.Unit_Delay_InitialCondition_lj;



      /* InitializeConditions for UnitDelay: '<S267>/Unit_Delay1' */

      L4_MABX_DW.Unit_Delay1_DSTATE_h = L4_MABX_P.Unit_Delay1_InitialCondition_a;



      /* InitializeConditions for UnitDelay: '<S268>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_fi = L4_MABX_P.Unit_Delay_InitialCondition_bm;



      /* InitializeConditions for UnitDelay: '<S272>/FixPt Unit Delay2' */

      L4_MABX_DW.FixPtUnitDelay2_DSTATE_gq =

        L4_MABX_P.FixPtUnitDelay2_InitialCondit_a;



      /* InitializeConditions for UnitDelay: '<S272>/FixPt Unit Delay1' */

      L4_MABX_DW.FixPtUnitDelay1_DSTATE_a =

        L4_MABX_P.FixPtUnitDelay1_InitialCondit_o;



      /* InitializeConditions for UnitDelay: '<S267>/Unit_Delay2' */

      L4_MABX_DW.Unit_Delay2_DSTATE_m = L4_MABX_P.Unit_Delay2_InitialCondition_j;



      /* InitializeConditions for UnitDelay: '<S222>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_fz = L4_MABX_P.Unit_Delay_InitialCondition_kg;

      L4_MABX_DW.Throttle_controller_gov_MODE = true;

    }



    /* DataTypeConversion: '<S219>/Data Type Conversion9' */

    L4_MABX_B.DataTypeConversion9_h = L4_MABX_B.SFunction1_o4_ki;



    /* DataTypeConversion: '<S219>/Data Type Conversion1' */

    L4_MABX_B.DataTypeConversion1_i = L4_MABX_B.SFunction1_o2_dgu;



    /* Sum: '<S219>/Add' */

    L4_MABX_B.Add_di = L4_MABX_B.DataTypeConversion9_h +

      L4_MABX_B.DataTypeConversion1_i;



    /* RelationalOperator: '<S224>/Relational Operator1' incorporates:

     *  Constant: '<S219>/Constant1'

     */

    L4_MABX_B.RelationalOperator1_n = (L4_MABX_B.Add_di >=

      L4_MABX_P.Constant1_Value_c);



    /* RelationalOperator: '<S224>/Relational Operator' incorporates:

     *  Constant: '<S219>/Constant3'

     */

    L4_MABX_B.RelationalOperator_d3 = (L4_MABX_B.Add_di <=

      L4_MABX_P.Constant3_Value_d);



    /* Outputs for Atomic SubSystem: '<S224>/If_Then_Else1' */



    /* Constant: '<S219>/Constant3' */

    L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator_d3,

                         L4_MABX_P.Constant3_Value_d, L4_MABX_B.Add_di,

                         &L4_MABX_B.If_Then_Else1_h);



    /* End of Outputs for SubSystem: '<S224>/If_Then_Else1' */



    /* Outputs for Atomic SubSystem: '<S224>/If_Then_Else' */



    /* Constant: '<S219>/Constant1' */

    L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator1_n,

                         L4_MABX_P.Constant1_Value_c,

                         L4_MABX_B.If_Then_Else1_h.Switch,

                         &L4_MABX_B.If_Then_Else_ct);



    /* End of Outputs for SubSystem: '<S224>/If_Then_Else' */



    /* DataTypeConversion: '<S219>/Data Type Conversion2' */

    L4_MABX_B.DataTypeConversion2_id = L4_MABX_B.SPN514_NominalFrictionPercentTo;



    /* RelationalOperator: '<S225>/Relational Operator1' incorporates:

     *  Constant: '<S219>/Constant2'

     */

    L4_MABX_B.RelationalOperator1_ch = (L4_MABX_B.DataTypeConversion2_id >=

      L4_MABX_P.Constant2_Value_b);



    /* RelationalOperator: '<S225>/Relational Operator' incorporates:

     *  Constant: '<S219>/Constant4'

     */

    L4_MABX_B.RelationalOperator_j = (L4_MABX_B.DataTypeConversion2_id <=

      L4_MABX_P.Constant4_Value);



    /* Outputs for Atomic SubSystem: '<S225>/If_Then_Else1' */



    /* Constant: '<S219>/Constant4' */

    L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator_j,

                         L4_MABX_P.Constant4_Value,

                         L4_MABX_B.DataTypeConversion2_id,

                         &L4_MABX_B.If_Then_Else1_kg);



    /* End of Outputs for SubSystem: '<S225>/If_Then_Else1' */



    /* Outputs for Atomic SubSystem: '<S225>/If_Then_Else' */



    /* Constant: '<S219>/Constant2' */

    L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator1_ch,

                         L4_MABX_P.Constant2_Value_b,

                         L4_MABX_B.If_Then_Else1_kg.Switch,

                         &L4_MABX_B.If_Then_Else_bo);



    /* End of Outputs for SubSystem: '<S225>/If_Then_Else' */



    /* DataTypeConversion: '<S219>/Data Type Conversion3' */

    L4_MABX_B.DataTypeConversion3_h = L4_MABX_B.SPN2978_EstEngParasiticLossesPe;



    /* RelationalOperator: '<S226>/Relational Operator1' incorporates:

     *  Constant: '<S219>/Constant5'

     */

    L4_MABX_B.RelationalOperator1_ln = (L4_MABX_B.DataTypeConversion3_h >=

      L4_MABX_P.Constant5_Value);



    /* RelationalOperator: '<S226>/Relational Operator' incorporates:

     *  Constant: '<S219>/Constant6'

     */

    L4_MABX_B.RelationalOperator_fd = (L4_MABX_B.DataTypeConversion3_h <=

      L4_MABX_P.Constant6_Value);



    /* Outputs for Atomic SubSystem: '<S226>/If_Then_Else1' */



    /* Constant: '<S219>/Constant6' */

    L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator_fd,

                         L4_MABX_P.Constant6_Value,

                         L4_MABX_B.DataTypeConversion3_h,

                         &L4_MABX_B.If_Then_Else1_dz);



    /* End of Outputs for SubSystem: '<S226>/If_Then_Else1' */



    /* Outputs for Atomic SubSystem: '<S226>/If_Then_Else' */



    /* Constant: '<S219>/Constant5' */

    L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator1_ln,

                         L4_MABX_P.Constant5_Value,

                         L4_MABX_B.If_Then_Else1_dz.Switch,

                         &L4_MABX_B.If_Then_Else_br);



    /* End of Outputs for SubSystem: '<S226>/If_Then_Else' */



    /* DataTypeConversion: '<S223>/Data Type Conversion5' */

    L4_MABX_B.DataTypeConversion5_i = L4_MABX_B.SFunction1_o1_au;



    /* Lookup_n-D: '<S230>/1-D Lookup Table' */

    L4_MABX_B.Coeff_of_drag_Cd = look1_binlcapw(L4_MABX_B.DataTypeConversion5_i,

      L4_MABX_P.uDLookupTable_bp01Data, L4_MABX_P.uDLookupTable_tableData, 2U);



    /* Gain: '<S230>/KPH_TO_M//S' */

    L4_MABX_B.KPH_TO_MS = L4_MABX_P.KPH_TO_MS_Gain *

      L4_MABX_B.DataTypeConversion5_i;



    /* Math: '<S230>/Math Function'

     *

     * About '<S230>/Math Function':

     *  Operator: magnitude^2

     */

    PositionFinalLimited = L4_MABX_B.KPH_TO_MS;

    L4_MABX_B.MathFunction = PositionFinalLimited * PositionFinalLimited;



    /* DataTypeConversion: '<S223>/Data Type Conversion' */

    L4_MABX_B.DataTypeConversion_ik = L4_MABX_B.SFunction1_o1_a5;



    /* Gain: '<S230>/KPA_TO_PA' */

    L4_MABX_B.KPA_TO_PA = L4_MABX_P.KPA_TO_PA_Gain *

      L4_MABX_B.DataTypeConversion_ik;



    /* DataTypeConversion: '<S223>/Data Type Conversion4' */

    L4_MABX_B.DataTypeConversion4_b = L4_MABX_B.SFunction1_o3_fp;



    /* Sum: '<S230>/Add' incorporates:

     *  Constant: '<S230>/Constant'

     */

    L4_MABX_B.Add_o = L4_MABX_B.DataTypeConversion4_b + L4_MABX_P.Constant_Value;



    /* Product: '<S230>/Product' incorporates:

     *  Constant: '<S230>/Constant1'

     */

    L4_MABX_B.Product_nm = L4_MABX_B.Add_o * L4_MABX_P.Constant1_Value_p;



    /* Product: '<S230>/Divide' */

    L4_MABX_B.Air_density_kgm3 = L4_MABX_B.KPA_TO_PA / L4_MABX_B.Product_nm;



    /* Product: '<S230>/Product1' incorporates:

     *  Constant: '<S223>/Veh_Frontal_Area_m^2'

     *  Constant: '<S230>/Constant2'

     */

    L4_MABX_B.Aerodynamic_resistance_Ra = L4_MABX_B.Coeff_of_drag_Cd *

      L4_MABX_P.Veh_Frontal_Area_m2_Value * L4_MABX_B.MathFunction *

      L4_MABX_B.Air_density_kgm3 * L4_MABX_P.Constant2_Value_h;



    /* DataTypeConversion: '<S223>/Data Type Conversion6' */

    L4_MABX_B.DataTypeConversion6_f = L4_MABX_B.PitchAngleExRange;



    /* Product: '<S231>/Divide' incorporates:

     *  Constant: '<S231>/Constant2'

     *  Constant: '<S231>/Constant3'

     */

    L4_MABX_B.grade_angle_radians = L4_MABX_B.DataTypeConversion6_f *

      L4_MABX_P.Constant2_Value_bc / L4_MABX_P.Constant3_Value_n;



    /* Trigonometry: '<S231>/Trigonometric Function' */

    L4_MABX_B.TrigonometricFunction_a = sin(L4_MABX_B.grade_angle_radians);



    /* Product: '<S231>/Product1' incorporates:

     *  Constant: '<S231>/Constant1'

     */

    L4_MABX_B.Gradient_resistance_Rg = L4_MABX_B.SPN1760_GrossCombinationVehicle

      * L4_MABX_B.TrigonometricFunction_a * L4_MABX_P.Constant1_Value_a;



    /* Gain: '<S234>/KPA_TO_M//S' */

    L4_MABX_B.KPA_TO_MS = L4_MABX_P.KPA_TO_MS_Gain *

      L4_MABX_B.DataTypeConversion5_i;



    /* Product: '<S234>/Divide2' incorporates:

     *  Constant: '<S234>/Constant2'

     *  Constant: '<S234>/Constant6'

     */

    L4_MABX_B.Divide2_c = L4_MABX_P.Constant2_Value_bq * L4_MABX_B.KPA_TO_MS /

      L4_MABX_P.Constant6_Value_g;



    /* Math: '<S234>/Math Function'

     *

     * About '<S234>/Math Function':

     *  Operator: magnitude^2

     */

    PositionFinalLimited = L4_MABX_B.Divide2_c;

    L4_MABX_B.MathFunction_l = PositionFinalLimited * PositionFinalLimited;



    /* Sum: '<S234>/Add' incorporates:

     *  Constant: '<S234>/Constant1'

     */

    L4_MABX_B.Add_nj = L4_MABX_P.Constant1_Value_m + L4_MABX_B.MathFunction_l;



    /* Outputs for Atomic SubSystem: '<S228>/If_Then_Else' */



    /* Constant: '<S223>/TIRE1_tire_pressure' incorporates:

     *  Constant: '<S228>/Truck166_tire_pressure'

     */

    L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator1_c,

                         L4_MABX_P.TIRE1_tire_pressure_Value,

                         L4_MABX_P.Truck166_tire_pressure_Value,

                         &L4_MABX_B.If_Then_Else_nr);



    /* End of Outputs for SubSystem: '<S228>/If_Then_Else' */



    /* Gain: '<S234>/KPA_TO_BAR' */

    L4_MABX_B.KPA_TO_BAR = L4_MABX_P.KPA_TO_BAR_Gain *

      L4_MABX_B.If_Then_Else_nr.Switch;



    /* Product: '<S234>/Divide' */

    L4_MABX_B.Divide_k = L4_MABX_B.Add_nj / L4_MABX_B.KPA_TO_BAR;



    /* Sum: '<S234>/Add1' incorporates:

     *  Constant: '<S234>/Constant'

     */

    L4_MABX_B.Coeff_of_rolling_resistance_Cr = L4_MABX_P.Constant_Value_h +

      L4_MABX_B.Divide_k;



    /* Product: '<S232>/Divide1' incorporates:

     *  Constant: '<S232>/Constant4'

     *  Constant: '<S232>/Constant5'

     */

    L4_MABX_B.grade_angle_radians_a = L4_MABX_B.DataTypeConversion6_f *

      L4_MABX_P.Constant4_Value_o / L4_MABX_P.Constant5_Value_p;



    /* Trigonometry: '<S232>/Trigonometric Function' */

    L4_MABX_B.TrigonometricFunction_e = cos(L4_MABX_B.grade_angle_radians_a);



    /* Product: '<S232>/Product2' incorporates:

     *  Constant: '<S232>/Constant3'

     */

    L4_MABX_B.Rolling_resistance_Rr = L4_MABX_B.Coeff_of_rolling_resistance_Cr *

      L4_MABX_B.SPN1760_GrossCombinationVehicle *

      L4_MABX_B.TrigonometricFunction_e * L4_MABX_P.Constant3_Value_p;



    /* Sum: '<S228>/Add' incorporates:

     *  Constant: '<S228>/Constant'

     */

    L4_MABX_B.TotalTractiveForce_N = ((L4_MABX_B.Aerodynamic_resistance_Ra +

      L4_MABX_B.Gradient_resistance_Rg) + L4_MABX_B.Rolling_resistance_Rr) +

      L4_MABX_P.Constant_Value_g;



    /* Saturate: '<S223>/Saturation' */

    DeltaTime = L4_MABX_B.SPN526_TransActualGearRatio;

    Time56 = L4_MABX_P.Saturation_LowerSat_p;

    AccelerationAverage = L4_MABX_P.Saturation_UpperSat_n;

    if (DeltaTime > AccelerationAverage) {

      L4_MABX_B.Saturation_g = AccelerationAverage;

    } else if (DeltaTime < Time56) {

      L4_MABX_B.Saturation_g = Time56;

    } else {

      L4_MABX_B.Saturation_g = DeltaTime;

    }



    /* End of Saturate: '<S223>/Saturation' */



    /* MATLAB Function: '<S223>/F_wheel_to_Tq_eng' incorporates:

     *  Constant: '<S223>/N_rar'

     *  Constant: '<S223>/R_wheel_m'

     *  Constant: '<S223>/eta'

     */

    /* MATLAB Function 'STATE_CONTROL_10ms/Throttle_controller_gov/Determine_engine_torque_and_losses/CalculateRoadLoadTorque/F_wheel_to_Tq_eng': '<S229>:1' */

    /* '<S229>:1:3' */

    L4_MABX_B.road_load_tq = L4_MABX_B.TotalTractiveForce_N *

      L4_MABX_P.R_wheel_m_Value / L4_MABX_P.N_rar_Value / L4_MABX_B.Saturation_g

      / L4_MABX_P.eta_Value;



    /* DataTypeConversion: '<S223>/Data Type Conversion1' */

    L4_MABX_B.DataTypeConversion1_b = L4_MABX_B.SPN544_EngineReferenceTorque;



    /* Product: '<S223>/Divide' */

    L4_MABX_B.RoadLoadTorque_fract = L4_MABX_B.road_load_tq /

      L4_MABX_B.DataTypeConversion1_b;



    /* Gain: '<S223>/Gain' */

    L4_MABX_B.RoadLoadTorque_pct = L4_MABX_P.Gain_Gain_n *

      L4_MABX_B.RoadLoadTorque_fract;



    /* Outputs for Atomic SubSystem: '<S219>/If_Then_Else' */



    /* Constant: '<S219>/UseFeedForwardRoadLoad' incorporates:

     *  Constant: '<S219>/ZeroRoadLoadCPV'

     */

    L4_MABX_If_Then_Else(L4_MABX_P.UseFeedForwardRoadLoad_Value,

                         L4_MABX_B.RoadLoadTorque_pct,

                         L4_MABX_P.ZeroRoadLoadCPV_Value,

                         &L4_MABX_B.If_Then_Else_as);



    /* End of Outputs for SubSystem: '<S219>/If_Then_Else' */



    /* Sum: '<S219>/Add1' */

    L4_MABX_B.FeedForwardTorque_pct = (L4_MABX_B.If_Then_Else_bo.Switch +

      L4_MABX_B.If_Then_Else_br.Switch) + L4_MABX_B.If_Then_Else_as.Switch;



    /* UnitDelay: '<S220>/Unit_Delay1' */

    L4_MABX_B.Unit_Delay1_m = L4_MABX_DW.Unit_Delay1_DSTATE_p1;



    /* Logic: '<S220>/Logical Operator' incorporates:

     *  Constant: '<S220>/Constant1'

     */

    L4_MABX_B.f_gpid_reset = (L4_MABX_P.Constant1_Value_g1 ||

      L4_MABX_B.Unit_Delay1_m);



    /* Sum: '<S220>/Subtract' */

    L4_MABX_B.Subtract_f = L4_MABX_B.VSPD_TARGET_KPH_APV_g -

      L4_MABX_B.VSPD_HYST_KPH_APV_f;



    /* RelationalOperator: '<S220>/Relational Operator' */

    L4_MABX_B.RelationalOperator_fl = (L4_MABX_B.DataTypeConversion4_ib >

      L4_MABX_B.Subtract_f);



    /* UnitDelay: '<S220>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_d5 = L4_MABX_DW.Unit_Delay_DSTATE_lq;



    /* RelationalOperator: '<S220>/Relational Operator1' */

    L4_MABX_B.RelationalOperator1_d3 = (L4_MABX_B.RelationalOperator_fl !=

      L4_MABX_B.Unit_Delay_d5);



    /* Lookup_n-D: '<S241>/2D_Lookup_Table' */

    L4_MABX_B.uD_Lookup_Table_am = look2_binlcapw

      (L4_MABX_B.SPN1760_GrossCombinationVehicle,

       L4_MABX_B.SPN526_TransActualGearRatio, TQ_DEM_MASS_STEP_MPV,

       TQ_DEM_GEAR_RATIO_STEP_MPV, TQ_DEM_KP_DATA_MPV,

       L4_MABX_P.uD_Lookup_Table_maxIndex, 8U);



    /* Lookup_n-D: '<S242>/2D_Lookup_Table' */

    L4_MABX_B.uD_Lookup_Table_o = look2_binlcapw

      (L4_MABX_B.SPN1760_GrossCombinationVehicle,

       L4_MABX_B.SPN526_TransActualGearRatio, TQ_DEM_MASS_STEP_MPV,

       TQ_DEM_GEAR_RATIO_STEP_MPV, TQ_DEM_KI_DATA_MPV,

       L4_MABX_P.uD_Lookup_Table_maxIndex_p, 8U);



    /* Lookup_n-D: '<S243>/2D_Lookup_Table' */

    L4_MABX_B.uD_Lookup_Table_h = look2_binlcapw

      (L4_MABX_B.SPN1760_GrossCombinationVehicle,

       L4_MABX_B.SPN526_TransActualGearRatio, TQ_DEM_MASS_STEP_MPV,

       TQ_DEM_GEAR_RATIO_STEP_MPV, TQ_DEM_KD_DATA_MPV,

       L4_MABX_P.uD_Lookup_Table_maxIndex_a, 8U);



    /* Abs: '<S244>/Abs' */

    L4_MABX_B.Abs_igm = fabs(L4_MABX_B.uD_Lookup_Table_o);



    /* Abs: '<S244>/Abs1' */

    L4_MABX_B.Abs1_a = fabs(L4_MABX_B.uD_Lookup_Table_h);



    /* UnitDelay: '<S247>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_i0 = L4_MABX_DW.Unit_Delay_DSTATE_be;



    /* Logic: '<S247>/Logical Operator1' */

    L4_MABX_B.LogicalOperator1_o = (L4_MABX_B.Unit_Delay_i0 ||

      L4_MABX_B.f_gpid_reset);



    /* UnitDelay: '<S267>/Unit_Delay1' */

    L4_MABX_B.Unit_Delay1_dw = L4_MABX_DW.Unit_Delay1_DSTATE_h;



    /* Logic: '<S267>/Logical Operator' */

    L4_MABX_B.LogicalOperator_at = (L4_MABX_B.LogicalOperator1_o ||

      L4_MABX_B.Unit_Delay1_dw);



    /* UnitDelay: '<S268>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_ne = L4_MABX_DW.Unit_Delay_DSTATE_fi;



    /* Logic: '<S268>/Logical Operator1' */

    L4_MABX_B.LogicalOperator1_kz = (L4_MABX_B.LogicalOperator1_o ||

      L4_MABX_B.Unit_Delay_ne);



    /* UnitDelay: '<S272>/FixPt Unit Delay2' */

    L4_MABX_B.FixPtUnitDelay2_a = L4_MABX_DW.FixPtUnitDelay2_DSTATE_gq;



    /* UnitDelay: '<S272>/FixPt Unit Delay1' */

    L4_MABX_B.Xold_a = L4_MABX_DW.FixPtUnitDelay1_DSTATE_a;



    /* Switch: '<S272>/Init' */

    if (L4_MABX_B.FixPtUnitDelay2_a != 0) {

      L4_MABX_B.Init_pu = L4_MABX_B.VSPD_TARGET_KPH_APV_g;

    } else {

      L4_MABX_B.Init_pu = L4_MABX_B.Xold_a;

    }



    /* End of Switch: '<S272>/Init' */



    /* Abs: '<S268>/Abs' incorporates:

     *  Constant: '<S212>/TqDemSlewInc'

     */

    L4_MABX_B.Abs_n = fabs(L4_MABX_P.TqDemSlewInc_Value);



    /* Product: '<S268>/Product1' incorporates:

     *  Constant: '<S212>/TqDemDt'

     */

    L4_MABX_B.Product1_g = L4_MABX_B.Abs_n * L4_MABX_P.TqDemDt_Value;



    /* Sum: '<S268>/Add1' */

    L4_MABX_B.Add1_g = L4_MABX_B.Init_pu + L4_MABX_B.Product1_g;



    /* MinMax: '<S268>/MinMax2' */

    DeltaTime = L4_MABX_B.VSPD_TARGET_KPH_APV_g;

    PositionFinalLimited = L4_MABX_B.Add1_g;

    if ((DeltaTime < PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

      PositionFinalLimited = DeltaTime;

    }



    L4_MABX_B.MinMax2_n = PositionFinalLimited;



    /* End of MinMax: '<S268>/MinMax2' */



    /* Abs: '<S268>/Abs1' incorporates:

     *  Constant: '<S212>/TqDemSlewDec'

     */

    L4_MABX_B.Abs1_d = fabs(L4_MABX_P.TqDemSlewDec_Value);



    /* Product: '<S268>/Product2' incorporates:

     *  Constant: '<S212>/TqDemDt'

     */

    L4_MABX_B.Product2_bn = L4_MABX_P.TqDemDt_Value * L4_MABX_B.Abs1_d;



    /* Sum: '<S268>/Subtract1' */

    L4_MABX_B.Subtract1_o = L4_MABX_B.Init_pu - L4_MABX_B.Product2_bn;



    /* MinMax: '<S268>/MinMax1' */

    DeltaTime = L4_MABX_B.MinMax2_n;

    PositionFinalLimited = L4_MABX_B.Subtract1_o;

    if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

      PositionFinalLimited = DeltaTime;

    }



    L4_MABX_B.MinMax1_g = PositionFinalLimited;



    /* End of MinMax: '<S268>/MinMax1' */



    /* Outputs for Atomic SubSystem: '<S268>/If_Then_Else' */

    L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator1_kz,

                         L4_MABX_B.DataTypeConversion4_ib, L4_MABX_B.MinMax1_g,

                         &L4_MABX_B.If_Then_Else_cp);



    /* End of Outputs for SubSystem: '<S268>/If_Then_Else' */



    /* Sum: '<S245>/Subtract' */

    L4_MABX_B.Subtract_jb = L4_MABX_B.If_Then_Else_cp.Switch -

      L4_MABX_B.DataTypeConversion4_ib;



    /* MinMax: '<S267>/MinMax1' incorporates:

     *  Constant: '<S212>/TqDemDt'

     *  Constant: '<S212>/TqDemTFildCtrlErrorSecs'

     */

    DeltaTime = L4_MABX_P.TqDemDt_Value;

    PositionFinalLimited = L4_MABX_P.TqDemTFildCtrlErrorSecs_Value;

    if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

      PositionFinalLimited = DeltaTime;

    }



    L4_MABX_B.MinMax1_d = PositionFinalLimited;



    /* End of MinMax: '<S267>/MinMax1' */



    /* Saturate: '<S267>/Saturation' */

    DeltaTime = L4_MABX_B.MinMax1_d;

    Time56 = L4_MABX_P.Saturation_LowerSat_g5;

    AccelerationAverage = L4_MABX_P.Saturation_UpperSat_f;

    if (DeltaTime > AccelerationAverage) {

      L4_MABX_B.Saturation_d = AccelerationAverage;

    } else if (DeltaTime < Time56) {

      L4_MABX_B.Saturation_d = Time56;

    } else {

      L4_MABX_B.Saturation_d = DeltaTime;

    }



    /* End of Saturate: '<S267>/Saturation' */



    /* Product: '<S267>/Divide' incorporates:

     *  Constant: '<S212>/TqDemDt'

     */

    L4_MABX_B.Divide_n = L4_MABX_P.TqDemDt_Value / L4_MABX_B.Saturation_d;



    /* Product: '<S267>/Product2' */

    L4_MABX_B.Product2_l = L4_MABX_B.Subtract_jb * L4_MABX_B.Divide_n;



    /* Sum: '<S267>/Subtract1' incorporates:

     *  Constant: '<S267>/Constant1'

     */

    L4_MABX_B.Subtract1_k = L4_MABX_P.Constant1_Value_ci - L4_MABX_B.Divide_n;



    /* UnitDelay: '<S267>/Unit_Delay2' */

    L4_MABX_B.Unit_Delay2_o = L4_MABX_DW.Unit_Delay2_DSTATE_m;



    /* Product: '<S267>/Product1' */

    L4_MABX_B.Product1_p = L4_MABX_B.Subtract1_k * L4_MABX_B.Unit_Delay2_o;



    /* Sum: '<S267>/Add1' */

    L4_MABX_B.Add1_i = L4_MABX_B.Product2_l + L4_MABX_B.Product1_p;



    /* Outputs for Atomic SubSystem: '<S267>/If_Then_Else' */

    L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator_at, L4_MABX_B.Subtract_jb,

                         L4_MABX_B.Add1_i, &L4_MABX_B.If_Then_Else_k2);



    /* End of Outputs for SubSystem: '<S267>/If_Then_Else' */



    /* RelationalOperator: '<S252>/Compare' incorporates:

     *  Constant: '<S252>/Constant'

     */

    L4_MABX_B.Compare_go = (L4_MABX_B.Abs1_a >

      L4_MABX_P.CompareToConstant1_const_i);



    /* Outputs for Enabled SubSystem: '<S244>/Calculate_D_term' */



    /* Constant: '<S212>/TqDemDt' incorporates:

     *  Constant: '<S212>/TqDemTFildTSecs'

     */

    L4_MABX_Calculate_D_term(L4_MABX_B.Compare_go, L4_MABX_B.uD_Lookup_Table_h,

      L4_MABX_P.TqDemDt_Value, L4_MABX_B.LogicalOperator1_o,

      L4_MABX_B.If_Then_Else_k2.Switch, L4_MABX_P.TqDemTFildTSecs_Value,

      &L4_MABX_B.Calculate_D_term_h, &L4_MABX_DW.Calculate_D_term_h,

      &L4_MABX_P.Calculate_D_term_h);



    /* End of Outputs for SubSystem: '<S244>/Calculate_D_term' */



    /* Product: '<S250>/Product' */

    L4_MABX_B.Product_i = L4_MABX_B.uD_Lookup_Table_am *

      L4_MABX_B.If_Then_Else_k2.Switch;



    /* RelationalOperator: '<S212>/Relational Operator' */

    L4_MABX_B.RelationalOperator_a = (L4_MABX_B.SPN524_TransSelectedGear !=

      L4_MABX_B.SPN523_TransCurrentGear);



    /* UnitDelay: '<S222>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_m4 = L4_MABX_DW.Unit_Delay_DSTATE_fz;



    /* RelationalOperator: '<S251>/Compare' incorporates:

     *  Constant: '<S251>/Constant'

     */

    L4_MABX_B.Compare_pj = (L4_MABX_B.Abs_igm >

      L4_MABX_P.CompareToConstant_const_d);



    /* Outputs for Enabled SubSystem: '<S244>/Calculate_I_term' */



    /* Constant: '<S212>/TqDemDt' incorporates:

     *  Constant: '<S212>/GpidAwCondIntegration'

     *  Constant: '<S212>/TqDemAwHyst'

     */

    L4_MABX_Calculate_I_term(L4_MABX_B.Compare_pj, L4_MABX_B.Product_i,

      L4_MABX_B.uD_Lookup_Table_o, L4_MABX_B.If_Then_Else_ct.Switch,

      L4_MABX_B.If_Then_Else_k2.Switch, L4_MABX_B.LogicalOperator1_o,

      L4_MABX_P.TqDemDt_Value, L4_MABX_B.FeedForwardTorque_pct,

      L4_MABX_P.GpidAwCondIntegration_Value, L4_MABX_P.TqDemAwHyst_Value,

      L4_MABX_B.RelationalOperator_a, L4_MABX_B.Unit_Delay_m4,

      &L4_MABX_B.Calculate_I_term_n, &L4_MABX_DW.Calculate_I_term_n,

      &L4_MABX_P.Calculate_I_term_n);



    /* End of Outputs for SubSystem: '<S244>/Calculate_I_term' */



    /* RelationalOperator: '<S270>/min_relop' incorporates:

     *  Constant: '<S212>/TqDemSlewInc'

     *  Constant: '<S270>/min_val'

     */

    L4_MABX_B.min_relop_cbm = (L4_MABX_P.CheckStaticLowerBound_min_b <=

      L4_MABX_P.TqDemSlewInc_Value);



    /* Assertion: '<S270>/Assertion' */

    utAssert(L4_MABX_B.min_relop_cbm);



    /* Sum: '<S246>/Add' */

    L4_MABX_B.Add_ds = ((L4_MABX_B.Product_i +

                         L4_MABX_B.Calculate_I_term_n.If_Then_Else.Switch) +

                        L4_MABX_B.Calculate_D_term_h.Subtract) +

      L4_MABX_B.FeedForwardTorque_pct;



    /* RelationalOperator: '<S273>/Relational Operator1' incorporates:

     *  Constant: '<S212>/TqDemLimMax'

     */

    L4_MABX_B.RelationalOperator1_j = (L4_MABX_B.Add_ds >=

      L4_MABX_P.TqDemLimMax_Value);



    /* RelationalOperator: '<S273>/Relational Operator' incorporates:

     *  Constant: '<S212>/TqDemLimMin'

     */

    L4_MABX_B.RelationalOperator_p = (L4_MABX_B.Add_ds <=

      L4_MABX_P.TqDemLimMin_Value);



    /* Outputs for Atomic SubSystem: '<S273>/If_Then_Else1' */



    /* Constant: '<S212>/TqDemLimMin' */

    L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator_p,

                         L4_MABX_P.TqDemLimMin_Value, L4_MABX_B.Add_ds,

                         &L4_MABX_B.If_Then_Else1_h3);



    /* End of Outputs for SubSystem: '<S273>/If_Then_Else1' */



    /* Outputs for Atomic SubSystem: '<S273>/If_Then_Else' */



    /* Constant: '<S212>/TqDemLimMax' */

    L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator1_j,

                         L4_MABX_P.TqDemLimMax_Value,

                         L4_MABX_B.If_Then_Else1_h3.Switch,

                         &L4_MABX_B.If_Then_Else_pi);



    /* End of Outputs for SubSystem: '<S273>/If_Then_Else' */



    /* SignalConversion: '<S212>/OutportBufferForPID_d_term' */

    L4_MABX_B.PID_d_term_c = L4_MABX_B.Calculate_D_term_h.Subtract;



    /* SignalConversion: '<S212>/OutportBufferForPID_hold_i_term_f' */

    L4_MABX_B.PID_hold_i_term_f_b =

      L4_MABX_B.Calculate_I_term_n.LogicalOperator2;



    /* SignalConversion: '<S212>/OutportBufferForPID_i_term' */

    L4_MABX_B.PID_i_term_c = L4_MABX_B.Calculate_I_term_n.If_Then_Else.Switch;

  } else {

    if (L4_MABX_DW.Throttle_controller_gov_MODE) {

      /* Disable for Enabled SubSystem: '<S244>/Calculate_D_term' */

      if (L4_MABX_DW.Calculate_D_term_h.Calculate_D_term_MODE) {

        L4_Calculate_D_term_Disable(&L4_MABX_B.Calculate_D_term_h,

          &L4_MABX_DW.Calculate_D_term_h, &L4_MABX_P.Calculate_D_term_h);

      }



      /* End of Disable for SubSystem: '<S244>/Calculate_D_term' */



      /* Disable for Enabled SubSystem: '<S244>/Calculate_I_term' */

      if (L4_MABX_DW.Calculate_I_term_n.Calculate_I_term_MODE) {

        L4_Calculate_I_term_Disable(&L4_MABX_B.Calculate_I_term_n,

          &L4_MABX_DW.Calculate_I_term_n, &L4_MABX_P.Calculate_I_term_n);

      }



      /* End of Disable for SubSystem: '<S244>/Calculate_I_term' */



      /* Disable for Outport: '<S212>/PID_output' */

      L4_MABX_B.If_Then_Else_pi.Switch = L4_MABX_P.PID_output_Y0_c;



      /* Disable for Outport: '<S212>/PID_output_unlim' */

      L4_MABX_B.Add_ds = L4_MABX_P.PID_output_unlim_Y0;



      /* Disable for Outport: '<S212>/PID_control_error' */

      L4_MABX_B.If_Then_Else_k2.Switch = L4_MABX_P.PID_control_error_Y0;



      /* Disable for Outport: '<S212>/PID_p_term' */

      L4_MABX_B.Product_i = L4_MABX_P.PID_p_term_Y0;



      /* Disable for Outport: '<S212>/PID_i_term' */

      L4_MABX_B.PID_i_term_c = L4_MABX_P.PID_i_term_Y0;



      /* Disable for Outport: '<S212>/PID_d_term' */

      L4_MABX_B.PID_d_term_c = L4_MABX_P.PID_d_term_Y0;



      /* Disable for Outport: '<S212>/PID_hold_i_term_f' */

      L4_MABX_B.PID_hold_i_term_f_b = L4_MABX_P.PID_hold_i_term_f_Y0;

      L4_MABX_DW.Throttle_controller_gov_MODE = false;

    }

  }



  /* End of Outputs for SubSystem: '<S79>/Throttle_controller_gov' */



  /* Switch: '<S79>/Switch' incorporates:

   *  Constant: '<S79>/Constant3'

   */

  if (L4_MABX_B.F_Brake_control_active) {

    L4_MABX_B.ThrottlePID_Y_m = L4_MABX_P.Constant3_Value;

  } else {

    /* DataTypeConversion: '<S79>/Data Type Conversion3' */

    L4_MABX_B.DataTypeConversion3_m = L4_MABX_B.SPN544_EngineReferenceTorque;



    /* Product: '<S79>/Product' incorporates:

     *  Constant: '<S79>/Constant2'

     */

    L4_MABX_B.ThrottlePID_Y_c = L4_MABX_B.If_Then_Else_pi.Switch *

      L4_MABX_B.DataTypeConversion3_m * L4_MABX_P.Constant2_Value;

    L4_MABX_B.ThrottlePID_Y_m = L4_MABX_B.ThrottlePID_Y_c;

  }



  /* End of Switch: '<S79>/Switch' */



  /* MultiPortSwitch: '<S83>/Multiport Switch' incorporates:

   *  Constant: '<S83>/APTC_DISABLED_PEDAL_POSITION_APV'

   *  Constant: '<S83>/APTC_PEDAL_POS_SIG_SOURCE_APV'

   */

  switch (L4_MABX_P.APTC_PEDAL_POS_SIG_SOURCE_APV_V) {

   case ENUM_PEDAL_POS_SIGNAL_SOURCE_T_DISABLED:

    L4_MABX_B.MultiportSwitch = L4_MABX_P.APTC_DISABLED_PEDAL_POSITION_AP;

    break;



   case ENUM_PEDAL_POS_SIGNAL_SOURCE_T_CAN_EEC2_00:

    L4_MABX_B.MultiportSwitch = L4_MABX_B.uDLookupTable;

    break;



   case ENUM_PEDAL_POS_SIGNAL_SOURCE_T_SW_EMULATION:

    L4_MABX_B.MultiportSwitch = L4_MABX_B.ThrottlePID_Y_m;

    break;



   case ENUM_PEDAL_POS_SIGNAL_SOURCE_T_CAN_EEC2_00_AND_SW_EMULATION:

    /* MinMax: '<S83>/MinMax' */

    DeltaTime = L4_MABX_B.uDLookupTable;

    PositionFinalLimited = L4_MABX_B.ThrottlePID_Y_m;

    if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

      PositionFinalLimited = DeltaTime;

    }



    L4_MABX_B.MinMax_p = PositionFinalLimited;



    /* End of MinMax: '<S83>/MinMax' */

    L4_MABX_B.MultiportSwitch = L4_MABX_B.MinMax_p;

    break;



   default:

    L4_MABX_B.MultiportSwitch = L4_MABX_P.APTC_DISABLED_PEDAL_POSITION_AP;

    break;

  }



  /* End of MultiPortSwitch: '<S83>/Multiport Switch' */



  /* Outputs for Atomic SubSystem: '<S83>/If_Then_Else1' */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator_d, L4_MABX_B.uDLookupTable,

                       L4_MABX_B.MultiportSwitch, &L4_MABX_B.If_Then_Else1_lw);



  /* End of Outputs for SubSystem: '<S83>/If_Then_Else1' */



  /* DataTypeConversion: '<S82>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_n = L4_MABX_B.SFunction1_o5_nl;



  /* Lookup_n-D: '<S85>/2D_Lookup_Table' */

  L4_MABX_B.uD_Lookup_Table = look2_binlcapw(L4_MABX_B.If_Then_Else1_lw.Switch,

    L4_MABX_B.DataTypeConversion1_n, APTC_TRQ_PED_INV_MAP_TRQ_STEPS,

    APTC_TRQ_PED_TRQ_ESPD_STEP_MPV, APTC_TRQ_PED_INV_MAP_PED_POS_MPV,

    L4_MABX_P.uD_Lookup_Table_maxIndex_h, 83U);



  /* Logic: '<S82>/Logical Operator' */

  L4_MABX_B.LogicalOperator_j = !L4_MABX_B.AutonomousEnabled_d;



  /* Outputs for Atomic SubSystem: '<S82>/If_Then_Else' */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator_j, Pedal_pwm_position,

                       L4_MABX_B.uD_Lookup_Table, &L4_MABX_B.If_Then_Else_f);



  /* End of Outputs for SubSystem: '<S82>/If_Then_Else' */



  /* RelationalOperator: '<S75>/Relational Operator' incorporates:

   *  Constant: '<S75>/Constant'

   */

  L4_MABX_B.APTC_arb_pedal_low_idl_sw_o = (APTC_PEDAL_LOW_IDLE_SW_THR_APV >

    L4_MABX_B.If_Then_Else_f.Switch);



  /* DataTypeConversion: '<S84>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_av = L4_MABX_B.SPN544_EngineReferenceTorque;



  /* RelationalOperator: '<S89>/Relational Operator1' incorporates:

   *  Constant: '<S84>/EngRefTqLimHigh'

   */

  L4_MABX_B.RelationalOperator1_i = (L4_MABX_B.DataTypeConversion1_av >=

    L4_MABX_P.EngRefTqLimHigh_Value);



  /* RelationalOperator: '<S89>/Relational Operator' incorporates:

   *  Constant: '<S84>/EngRefTqLimLow'

   */

  L4_MABX_B.RelationalOperator_ca = (L4_MABX_B.DataTypeConversion1_av <=

    L4_MABX_P.EngRefTqLimLow_Value);



  /* Outputs for Atomic SubSystem: '<S89>/If_Then_Else1' */



  /* Constant: '<S84>/EngRefTqLimLow' */

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator_ca,

                       L4_MABX_P.EngRefTqLimLow_Value,

                       L4_MABX_B.DataTypeConversion1_av,

                       &L4_MABX_B.If_Then_Else1_lo);



  /* End of Outputs for SubSystem: '<S89>/If_Then_Else1' */



  /* Outputs for Atomic SubSystem: '<S89>/If_Then_Else' */



  /* Constant: '<S84>/EngRefTqLimHigh' */

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator1_i,

                       L4_MABX_P.EngRefTqLimHigh_Value,

                       L4_MABX_B.If_Then_Else1_lo.Switch,

                       &L4_MABX_B.If_Then_Else_ff);



  /* End of Outputs for SubSystem: '<S89>/If_Then_Else' */



  /* Sum: '<S84>/Subtract' incorporates:

   *  Constant: '<S84>/FrictionTrqAtRefTrqSpeed'

   */

  L4_MABX_B.Subtract_j0 = L4_MABX_B.If_Then_Else_ff.Switch -

    L4_MABX_P.FrictionTrqAtRefTrqSpeed_Value;



  /* Product: '<S84>/Divide' incorporates:

   *  Constant: '<S84>/Constant1'

   */

  L4_MABX_B.Divide_h = L4_MABX_B.If_Then_Else1_lw.Switch *

    L4_MABX_P.Constant1_Value_fg / L4_MABX_B.Subtract_j0;



  /* RelationalOperator: '<S90>/Relational Operator1' incorporates:

   *  Constant: '<S84>/APPTqPercentMax'

   */

  L4_MABX_B.RelationalOperator1_a = (L4_MABX_B.Divide_h >=

    L4_MABX_P.APPTqPercentMax_Value);



  /* RelationalOperator: '<S90>/Relational Operator' incorporates:

   *  Constant: '<S84>/APPTqPercentMin'

   */

  L4_MABX_B.RelationalOperator_n = (L4_MABX_B.Divide_h <=

    L4_MABX_P.APPTqPercentMin_Value);



  /* Outputs for Atomic SubSystem: '<S90>/If_Then_Else1' */



  /* Constant: '<S84>/APPTqPercentMin' */

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator_n,

                       L4_MABX_P.APPTqPercentMin_Value, L4_MABX_B.Divide_h,

                       &L4_MABX_B.If_Then_Else1_pf);



  /* End of Outputs for SubSystem: '<S90>/If_Then_Else1' */



  /* Outputs for Atomic SubSystem: '<S90>/If_Then_Else' */



  /* Constant: '<S84>/APPTqPercentMax' */

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator1_a,

                       L4_MABX_P.APPTqPercentMax_Value,

                       L4_MABX_B.If_Then_Else1_pf.Switch,

                       &L4_MABX_B.If_Then_Else_iz);



  /* End of Outputs for SubSystem: '<S90>/If_Then_Else' */



  /* MultiPortSwitch: '<S76>/Autonomous Mode Switch' incorporates:

   *  Constant: '<S76>/AUTONOMOUS_MODE_SELECTOR_APV'

   *  Constant: '<S76>/GhostMode'

   */

  if (AUTONOMOUS_MODE_SELECTOR_APV == ENUM_AUTONOMOUS_MODE_T_AUTO) {

    AutonomousOutputEnabled = L4_MABX_B.AutonomousEnabled_d;

  } else {

    AutonomousOutputEnabled = (L4_MABX_P.GhostMode_Value != 0);

  }



  /* End of MultiPortSwitch: '<S76>/Autonomous Mode Switch' */



  /* Switch: '<S76>/Switch' incorporates:

   *  Constant: '<S76>/Failure'

   *  Constant: '<S76>/Running'

   */

  if (EStop) {

    tmp_1 = L4_MABX_P.Running_Value;

    if (tmp_1 < 0) {

      tmp_1 = 0;

    }



    MABX_Mode = (uint8_T)tmp_1;

  } else {

    tmp_1 = L4_MABX_P.Failure_Value;

    if (tmp_1 < 0) {

      tmp_1 = 0;

    }



    MABX_Mode = (uint8_T)tmp_1;

  }



  /* End of Switch: '<S76>/Switch' */



  /* DataTypeConversion: '<S104>/Data Type Conversion2' */

  PositionFinalLimited = floor(L4_MABX_B.SFunction1_o8_fp);

  if (rtIsNaN(PositionFinalLimited) || rtIsInf(PositionFinalLimited)) {

    PositionFinalLimited = 0.0;

  } else {

    PositionFinalLimited = fmod(PositionFinalLimited, 256.0);

  }



  L4_MABX_B.DataTypeConversion2_ew = (uint8_T)(PositionFinalLimited < 0.0 ?

    (int32_T)(uint8_T)-(int8_T)(uint8_T)-PositionFinalLimited : (int32_T)

    (uint8_T)PositionFinalLimited);



  /* End of DataTypeConversion: '<S104>/Data Type Conversion2' */



  /* DataTypeConversion: '<S104>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_lr = (ENUM_SWITCH_T)

    L4_MABX_B.DataTypeConversion2_ew;



  /* DataTypeConversion: '<S104>/Data Type Conversion3' */

  PositionFinalLimited = floor(L4_MABX_B.SFunction1_o4_nj);

  if (rtIsNaN(PositionFinalLimited) || rtIsInf(PositionFinalLimited)) {

    PositionFinalLimited = 0.0;

  } else {

    PositionFinalLimited = fmod(PositionFinalLimited, 256.0);

  }



  L4_MABX_B.DataTypeConversion3_ps = (uint8_T)(PositionFinalLimited < 0.0 ?

    (int32_T)(uint8_T)-(int8_T)(uint8_T)-PositionFinalLimited : (int32_T)

    (uint8_T)PositionFinalLimited);



  /* End of DataTypeConversion: '<S104>/Data Type Conversion3' */



  /* DataTypeConversion: '<S104>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_lu = (ENUM_SWITCH_T)

    L4_MABX_B.DataTypeConversion3_ps;



  /* RelationalOperator: '<S104>/Relational Operator3' incorporates:

   *  Constant: '<S104>/CPV3'

   */

  L4_MABX_B.RelationalOperator3_c[0] = (L4_MABX_B.DataTypeConversion_lr ==

    L4_MABX_P.CPV3_Value_p);

  L4_MABX_B.RelationalOperator3_c[1] = (L4_MABX_B.DataTypeConversion1_lu ==

    L4_MABX_P.CPV3_Value_p);



  /* Logic: '<S104>/Logical Operator4' */

  L4_MABX_B.LogicalOperator4_o = (L4_MABX_B.RelationalOperator3_c[0] &&

    L4_MABX_B.RelationalOperator3_c[1]);



  /* Gain: '<S104>/Gain4' */

  L4_MABX_B.Primary_brake_circuit_pressure_ = L4_MABX_P.Gain4_Gain *

    L4_MABX_B.PressureP42;



  /* Gain: '<S104>/Gain5' */

  L4_MABX_B.Secondary_brake_circuit_pressur = L4_MABX_P.Gain5_Gain *

    L4_MABX_B.PressureP4;



  /* RelationalOperator: '<S104>/Relational Operator4' incorporates:

   *  Constant: '<S104>/BRAKE_APPL_THRESHOLD_KPA_APV'

   */

  L4_MABX_B.RelationalOperator4[0] = (L4_MABX_B.Primary_brake_circuit_pressure_ >

    L4_MABX_P.BRAKE_APPL_THRESHOLD_KPA_APV_Va);

  L4_MABX_B.RelationalOperator4[1] = (L4_MABX_B.Secondary_brake_circuit_pressur >

    L4_MABX_P.BRAKE_APPL_THRESHOLD_KPA_APV_Va);



  /* Logic: '<S104>/Logical Operator3' */

  L4_MABX_B.F_Service_brake_pressure_applie = (L4_MABX_B.RelationalOperator4[0] ||

    L4_MABX_B.RelationalOperator4[1]);



  /* RelationalOperator: '<S104>/Relational Operator6' incorporates:

   *  Constant: '<S104>/CPV4'

   */

  L4_MABX_B.RelationalOperator6[0] = (L4_MABX_B.DataTypeConversion_lr ==

    L4_MABX_P.CPV4_Value_n);

  L4_MABX_B.RelationalOperator6[1] = (L4_MABX_B.DataTypeConversion1_lu ==

    L4_MABX_P.CPV4_Value_n);



  /* Logic: '<S104>/Logical Operator' */

  L4_MABX_B.F_Brake_sw_CAN = (L4_MABX_B.RelationalOperator6[0] ||

    L4_MABX_B.RelationalOperator6[1]);



  /* Logic: '<S104>/Logical Operator5' */

  L4_MABX_B.LogicalOperator5_n = (L4_MABX_B.F_Service_brake_pressure_applie ||

    L4_MABX_B.F_Brake_sw_CAN);



  /* Outputs for Atomic SubSystem: '<S104>/If_Then_Else' */

  L4_MABX_If_Then_Else_l(L4_MABX_B.LogicalOperator4_o,

    L4_MABX_B.F_Service_brake_pressure_applie, L4_MABX_B.LogicalOperator5_n,

    &L4_MABX_B.If_Then_Else_la);



  /* End of Outputs for SubSystem: '<S104>/If_Then_Else' */



  /* RelationalOperator: '<S108>/Relational Operator1' incorporates:

   *  Constant: '<S108>/SPN904_ZERO_SPD_CPV'

   */

  L4_MABX_B.F_Vehicle_stopped = (L4_MABX_B.DataTypeConversion5_o <=

    L4_MABX_P.SPN904_ZERO_SPD_CPV_Value);



  /* Sum: '<S105>/Add' */

  L4_MABX_B.Add_d = L4_MABX_B.Primary_brake_circuit_pressure_ +

    L4_MABX_B.Secondary_brake_circuit_pressur;



  /* Gain: '<S105>/Gain' */

  L4_MABX_B.Gain_g = L4_MABX_P.Gain_Gain_g * L4_MABX_B.Add_d;



  /* Outputs for Enabled SubSystem: '<S105>/Determine_shift_interlock_brake_pressure_target' incorporates:

   *  EnablePort: '<S184>/Enable'

   */

  if (L4_MABX_DW.Determine_shift_interlock_brake) {

    /* Disable for Outport: '<S184>/Shift_interlock_brake_press_target_kpa' */

    L4_MABX_B.If_Then_Else_il.Switch = L4_MABX_P.Shift_interlock_brake_press_tar;



    /* Disable for Outport: '<S184>/F_Shift_interlock_conditions_met' */

    L4_MABX_B.F_Shift_interlock_conditions_me =

      L4_MABX_P.F_Shift_interlock_conditions_me;

    L4_MABX_DW.Determine_shift_interlock_brake = false;

  }



  /* End of Outputs for SubSystem: '<S105>/Determine_shift_interlock_brake_pressure_target' */



  /* RelationalOperator: '<S206>/Compare' incorporates:

   *  Constant: '<S206>/Constant'

   */

  L4_MABX_B.Compare_g = (L4_MABX_B.VSPD_TARGET_KPH_APV_g ==

    L4_MABX_P.Constant_Value_ol);



  /* RelationalOperator: '<S109>/Relational Operator4' */

  L4_MABX_B.RelationalOperator4_l = (L4_MABX_B.VSPD_BRAKE_STOP_THRESH_KPH_AP_b >=

    L4_MABX_B.DataTypeConversion5_o);



  /* Logic: '<S109>/Logical Operator3' */

  L4_MABX_B.F_Hold_brakes_at_zero_d = (L4_MABX_B.F_Brake_control_active &&

    L4_MABX_B.Compare_g && L4_MABX_B.RelationalOperator4_l);



  /* Outputs for Enabled SubSystem: '<S105>/Determine_brake_hold_pressure_target' incorporates:

   *  EnablePort: '<S183>/Enable'

   */

  if (L4_MABX_B.F_Hold_brakes_at_zero_d) {

    if (!L4_MABX_DW.Determine_brake_hold_pressure_t) {

      /* InitializeConditions for UnitDelay: '<S183>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_c = L4_MABX_P.Unit_Delay_InitialCondition_d;



      /* InitializeConditions for UnitDelay: '<S187>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_or = L4_MABX_P.Unit_Delay_InitialCondition_fy;



      /* InitializeConditions for UnitDelay: '<S191>/FixPt Unit Delay2' */

      L4_MABX_DW.FixPtUnitDelay2_DSTATE_je =

        L4_MABX_P.FixPtUnitDelay2_InitialCondit_e;



      /* InitializeConditions for UnitDelay: '<S191>/FixPt Unit Delay1' */

      L4_MABX_DW.FixPtUnitDelay1_DSTATE_b =

        L4_MABX_P.FixPtUnitDelay1_InitialCondit_p;



      /* InitializeConditions for UnitDelay: '<S188>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_oj = L4_MABX_P.Unit_Delay_InitialCondition_k;

      L4_MABX_DW.Determine_brake_hold_pressure_t = true;

    }



    /* Logic: '<S183>/Logical Operator2' */

    L4_MABX_B.F_Brake_hold_conditions_met = (L4_MABX_B.If_Then_Else_la.Switch &&

      L4_MABX_B.F_Vehicle_stopped);



    /* UnitDelay: '<S183>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_a = L4_MABX_DW.Unit_Delay_DSTATE_c;



    /* UnitDelay: '<S187>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_h0 = L4_MABX_DW.Unit_Delay_DSTATE_or;



    /* Logic: '<S187>/Logical Operator1' incorporates:

     *  Constant: '<S183>/CPV1'

     */

    L4_MABX_B.LogicalOperator1_ou = (L4_MABX_P.CPV1_Value_p ||

      L4_MABX_B.Unit_Delay_h0);



    /* Outputs for Atomic SubSystem: '<S183>/If_Then_Else1' */



    /* Constant: '<S183>/CPV' */

    L4_MABX_If_Then_Else_g(L4_MABX_B.F_Brake_hold_conditions_met,

      L4_MABX_B.Unit_Delay_a, L4_MABX_P.CPV_Value_k, &L4_MABX_B.If_Then_Else1_mf);



    /* End of Outputs for SubSystem: '<S183>/If_Then_Else1' */



    /* UnitDelay: '<S191>/FixPt Unit Delay2' */

    L4_MABX_B.FixPtUnitDelay2_d = L4_MABX_DW.FixPtUnitDelay2_DSTATE_je;



    /* UnitDelay: '<S191>/FixPt Unit Delay1' */

    L4_MABX_B.Xold_b = L4_MABX_DW.FixPtUnitDelay1_DSTATE_b;



    /* Switch: '<S191>/Init' */

    if (L4_MABX_B.FixPtUnitDelay2_d != 0) {

      L4_MABX_B.Init_k = L4_MABX_B.If_Then_Else1_mf.Switch;

    } else {

      L4_MABX_B.Init_k = L4_MABX_B.Xold_b;

    }



    /* End of Switch: '<S191>/Init' */



    /* Abs: '<S187>/Abs' incorporates:

     *  Constant: '<S183>/BRAKE_PRESS_TARGET_S LEW_INC_APV'

     */

    L4_MABX_B.Abs_b = fabs(L4_MABX_P.BRAKE_PRESS_TARGET_SLEW_INC_APV);



    /* DigitalClock: '<S188>/Digital Clock' */

    L4_MABX_B.DigitalClock_c = L4_MABX_M->Timing.t[0];



    /* UnitDelay: '<S188>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_ka = L4_MABX_DW.Unit_Delay_DSTATE_oj;



    /* Sum: '<S188>/Subtract' */

    L4_MABX_B.Subtract_ko = L4_MABX_B.DigitalClock_c - L4_MABX_B.Unit_Delay_ka;



    /* Product: '<S187>/Product1' */

    L4_MABX_B.Product1_f = L4_MABX_B.Abs_b * L4_MABX_B.Subtract_ko;



    /* Sum: '<S187>/Add1' */

    L4_MABX_B.Add1_c = L4_MABX_B.Init_k + L4_MABX_B.Product1_f;



    /* MinMax: '<S187>/MinMax2' */

    DeltaTime = L4_MABX_B.If_Then_Else1_mf.Switch;

    PositionFinalLimited = L4_MABX_B.Add1_c;

    if ((DeltaTime < PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

      PositionFinalLimited = DeltaTime;

    }



    L4_MABX_B.MinMax2_c2 = PositionFinalLimited;



    /* End of MinMax: '<S187>/MinMax2' */



    /* Abs: '<S187>/Abs1' incorporates:

     *  Constant: '<S183>/BRAKE_PRESS_TARGET_SLEW_DEC_APV'

     */

    L4_MABX_B.Abs1_ar = fabs(L4_MABX_P.BRAKE_PRESS_TARGET_SLEW_DEC_APV);



    /* Product: '<S187>/Product2' */

    L4_MABX_B.Product2_c3 = L4_MABX_B.Subtract_ko * L4_MABX_B.Abs1_ar;



    /* Sum: '<S187>/Subtract1' */

    L4_MABX_B.Subtract1_ev = L4_MABX_B.Init_k - L4_MABX_B.Product2_c3;



    /* MinMax: '<S187>/MinMax1' */

    DeltaTime = L4_MABX_B.MinMax2_c2;

    PositionFinalLimited = L4_MABX_B.Subtract1_ev;

    if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

      PositionFinalLimited = DeltaTime;

    }



    L4_MABX_B.MinMax1_jw = PositionFinalLimited;



    /* End of MinMax: '<S187>/MinMax1' */



    /* Outputs for Atomic SubSystem: '<S187>/If_Then_Else' */

    L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator1_ou, L4_MABX_B.Gain_g,

                         L4_MABX_B.MinMax1_jw, &L4_MABX_B.If_Then_Else_nz);



    /* End of Outputs for SubSystem: '<S187>/If_Then_Else' */



    /* Outputs for Atomic SubSystem: '<S183>/If_Then_Else' */

    L4_MABX_If_Then_Else_g(L4_MABX_B.F_Brake_hold_conditions_met,

      L4_MABX_B.Unit_Delay_a, L4_MABX_B.If_Then_Else_nz.Switch,

      &L4_MABX_B.If_Then_Else_gj);



    /* End of Outputs for SubSystem: '<S183>/If_Then_Else' */



    /* RelationalOperator: '<S189>/min_relop' incorporates:

     *  Constant: '<S183>/BRAKE_PRESS_TARGET_S LEW_INC_APV'

     *  Constant: '<S189>/min_val'

     */

    L4_MABX_B.min_relop_i = (L4_MABX_P.CheckStaticLowerBound_min_i <=

      L4_MABX_P.BRAKE_PRESS_TARGET_SLEW_INC_APV);



    /* Assertion: '<S189>/Assertion' */

    utAssert(L4_MABX_B.min_relop_i);

  } else {

    if (L4_MABX_DW.Determine_brake_hold_pressure_t) {

      /* Disable for Outport: '<S183>/Brake_hold_brake_press_target_kpa' */

      L4_MABX_B.If_Then_Else_gj.Switch =

        L4_MABX_P.Brake_hold_brake_press_target_k;



      /* Disable for Outport: '<S183>/F_Brake_hold_conditions_met' */

      L4_MABX_B.F_Brake_hold_conditions_met =

        L4_MABX_P.F_Brake_hold_conditions_met_Y0;

      L4_MABX_DW.Determine_brake_hold_pressure_t = false;

    }

  }



  /* End of Outputs for SubSystem: '<S105>/Determine_brake_hold_pressure_target' */



  /* MinMax: '<S105>/MinMax' */

  DeltaTime = L4_MABX_B.If_Then_Else_il.Switch;

  PositionFinalLimited = L4_MABX_B.If_Then_Else_gj.Switch;

  if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.Brake_pressure_target_kpa = PositionFinalLimited;



  /* End of MinMax: '<S105>/MinMax' */



  /* Gain: '<S104>/Gain1' */

  L4_MABX_B.Bendix_2C2_Primary_brake_circui = L4_MABX_P.Gain1_Gain *

    L4_MABX_B.PressureP21;



  /* Gain: '<S104>/Gain2' */

  L4_MABX_B.Bendix_2C2_Secondary_brake_circ = L4_MABX_P.Gain2_Gain *

    L4_MABX_B.PressureP22;



  /* Sum: '<S106>/Add' */

  L4_MABX_B.Add_n = L4_MABX_B.Primary_brake_circuit_pressure_ +

    L4_MABX_B.Secondary_brake_circuit_pressur;



  /* Gain: '<S106>/Gain' */

  L4_MABX_B.brake_system_avg_appl_pressure_ = L4_MABX_P.Gain_Gain_i *

    L4_MABX_B.Add_n;



  /* Gain: '<S104>/Gain3' */

  L4_MABX_B.Primary_brake_circuit_pressur_n = L4_MABX_P.Gain3_Gain *

    L4_MABX_B.PressureP1;



  /* Product: '<S106>/Divide2' */

  L4_MABX_B.Divide2 = L4_MABX_B.brake_system_avg_appl_pressure_ /

    L4_MABX_B.Primary_brake_circuit_pressur_n;



  /* Gain: '<S106>/Gain5' */

  L4_MABX_B.Gain5 = L4_MABX_P.Gain5_Gain_l * L4_MABX_B.Divide2;



  /* Saturate: '<S106>/Saturation3' */

  DeltaTime = L4_MABX_B.Gain5;

  Time56 = L4_MABX_P.Saturation3_LowerSat;

  AccelerationAverage = L4_MABX_P.Saturation3_UpperSat;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Brake_appl_percent = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Brake_appl_percent = Time56;

  } else {

    L4_MABX_B.Brake_appl_percent = DeltaTime;

  }



  /* End of Saturate: '<S106>/Saturation3' */



  /* Outputs for Enabled SubSystem: '<S77>/Bendix_2C2_brake_application_pressure_feedback_controller' incorporates:

   *  EnablePort: '<S102>/Enable'

   */

  if (L4_MABX_B.F_Hold_brakes_at_zero_d) {

    if (!L4_MABX_DW.Bendix_2C2_brake_application_pr) {

      /* InitializeConditions for UnitDelay: '<S111>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_dc = L4_MABX_P.Unit_Delay_InitialCondition;



      /* InitializeConditions for UnitDelay: '<S115>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_omj =

        L4_MABX_P.Unit_Delay_InitialCondition_lt;



      /* InitializeConditions for UnitDelay: '<S135>/Unit_Delay1' */

      L4_MABX_DW.Unit_Delay1_DSTATE_b = L4_MABX_P.Unit_Delay1_InitialCondition;



      /* InitializeConditions for UnitDelay: '<S136>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_h4 = L4_MABX_P.Unit_Delay_InitialCondition_og;



      /* InitializeConditions for UnitDelay: '<S140>/FixPt Unit Delay2' */

      L4_MABX_DW.FixPtUnitDelay2_DSTATE_gm =

        L4_MABX_P.FixPtUnitDelay2_InitialConditio;



      /* InitializeConditions for UnitDelay: '<S140>/FixPt Unit Delay1' */

      L4_MABX_DW.FixPtUnitDelay1_DSTATE_g1 =

        L4_MABX_P.FixPtUnitDelay1_InitialConditio;



      /* InitializeConditions for UnitDelay: '<S135>/Unit_Delay2' */

      L4_MABX_DW.Unit_Delay2_DSTATE_dy = L4_MABX_P.Unit_Delay2_InitialCondition;



      /* InitializeConditions for UnitDelay: '<S110>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_i2 = L4_MABX_P.Unit_Delay_InitialCondition_p;

      L4_MABX_DW.Bendix_2C2_brake_application_pr = true;

    }



    /* Sum: '<S102>/Add' */

    L4_MABX_B.Add_my = L4_MABX_B.Bendix_2C2_Primary_brake_circui +

      L4_MABX_B.Bendix_2C2_Secondary_brake_circ;



    /* Gain: '<S102>/Gain' */

    L4_MABX_B.Gain_i = L4_MABX_P.Gain_Gain * L4_MABX_B.Add_my;



    /* Abs: '<S112>/Abs' incorporates:

     *  Constant: '<S102>/BRK_PRESS_DEM_KI_APV'

     */

    L4_MABX_B.Abs_k4 = fabs(L4_MABX_P.BRK_PRESS_DEM_KI_APV_Value);



    /* Abs: '<S112>/Abs1' incorporates:

     *  Constant: '<S102>/BRK_PRESS_DEM_KD_APV'

     */

    L4_MABX_B.Abs1_ap = fabs(L4_MABX_P.BRK_PRESS_DEM_KD_APV_Value);



    /* DigitalClock: '<S111>/Digital Clock' */

    L4_MABX_B.DigitalClock_j = L4_MABX_M->Timing.t[0];



    /* UnitDelay: '<S111>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_j = L4_MABX_DW.Unit_Delay_DSTATE_dc;



    /* Sum: '<S111>/Subtract' */

    L4_MABX_B.Subtract_jr = L4_MABX_B.DigitalClock_j - L4_MABX_B.Unit_Delay_j;



    /* UnitDelay: '<S115>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_nm = L4_MABX_DW.Unit_Delay_DSTATE_omj;



    /* Logic: '<S115>/Logical Operator1' incorporates:

     *  Constant: '<S102>/CPV2'

     */

    L4_MABX_B.LogicalOperator1_ax = (L4_MABX_B.Unit_Delay_nm ||

      L4_MABX_P.CPV2_Value_m);



    /* UnitDelay: '<S135>/Unit_Delay1' */

    L4_MABX_B.Unit_Delay1_i = L4_MABX_DW.Unit_Delay1_DSTATE_b;



    /* Logic: '<S135>/Logical Operator' */

    L4_MABX_B.LogicalOperator_m = (L4_MABX_B.LogicalOperator1_ax ||

      L4_MABX_B.Unit_Delay1_i);



    /* UnitDelay: '<S136>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_nl = L4_MABX_DW.Unit_Delay_DSTATE_h4;



    /* Logic: '<S136>/Logical Operator1' */

    L4_MABX_B.LogicalOperator1_mk = (L4_MABX_B.LogicalOperator1_ax ||

      L4_MABX_B.Unit_Delay_nl);



    /* UnitDelay: '<S140>/FixPt Unit Delay2' */

    L4_MABX_B.FixPtUnitDelay2_op = L4_MABX_DW.FixPtUnitDelay2_DSTATE_gm;



    /* UnitDelay: '<S140>/FixPt Unit Delay1' */

    L4_MABX_B.Xold_g3 = L4_MABX_DW.FixPtUnitDelay1_DSTATE_g1;



    /* Switch: '<S140>/Init' */

    if (L4_MABX_B.FixPtUnitDelay2_op != 0) {

      L4_MABX_B.Init_hw = L4_MABX_B.Brake_pressure_target_kpa;

    } else {

      L4_MABX_B.Init_hw = L4_MABX_B.Xold_g3;

    }



    /* End of Switch: '<S140>/Init' */



    /* Abs: '<S136>/Abs' incorporates:

     *  Constant: '<S102>/CPV4'

     */

    L4_MABX_B.Abs_l = fabs(L4_MABX_P.CPV4_Value);



    /* Product: '<S136>/Product1' */

    L4_MABX_B.Product1_b = L4_MABX_B.Abs_l * L4_MABX_B.Subtract_jr;



    /* Sum: '<S136>/Add1' */

    L4_MABX_B.Add1_hu = L4_MABX_B.Init_hw + L4_MABX_B.Product1_b;



    /* MinMax: '<S136>/MinMax2' */

    DeltaTime = L4_MABX_B.Brake_pressure_target_kpa;

    PositionFinalLimited = L4_MABX_B.Add1_hu;

    if ((DeltaTime < PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

      PositionFinalLimited = DeltaTime;

    }



    L4_MABX_B.MinMax2_b = PositionFinalLimited;



    /* End of MinMax: '<S136>/MinMax2' */



    /* Abs: '<S136>/Abs1' incorporates:

     *  Constant: '<S102>/CPV5'

     */

    L4_MABX_B.Abs1_d1 = fabs(L4_MABX_P.CPV5_Value);



    /* Product: '<S136>/Product2' */

    L4_MABX_B.Product2_dl = L4_MABX_B.Subtract_jr * L4_MABX_B.Abs1_d1;



    /* Sum: '<S136>/Subtract1' */

    L4_MABX_B.Subtract1_a = L4_MABX_B.Init_hw - L4_MABX_B.Product2_dl;



    /* MinMax: '<S136>/MinMax1' */

    DeltaTime = L4_MABX_B.MinMax2_b;

    PositionFinalLimited = L4_MABX_B.Subtract1_a;

    if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

      PositionFinalLimited = DeltaTime;

    }



    L4_MABX_B.MinMax1_ps = PositionFinalLimited;



    /* End of MinMax: '<S136>/MinMax1' */



    /* Outputs for Atomic SubSystem: '<S136>/If_Then_Else' */

    L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator1_mk, L4_MABX_B.Gain_i,

                         L4_MABX_B.MinMax1_ps, &L4_MABX_B.If_Then_Else_bg);



    /* End of Outputs for SubSystem: '<S136>/If_Then_Else' */



    /* Sum: '<S113>/Subtract' */

    L4_MABX_B.Subtract_n = L4_MABX_B.If_Then_Else_bg.Switch - L4_MABX_B.Gain_i;



    /* MinMax: '<S135>/MinMax1' incorporates:

     *  Constant: '<S102>/BRK_PRESS_DEM_T_FILT_CTRL_ERROR_APV'

     */

    DeltaTime = L4_MABX_B.Subtract_jr;

    PositionFinalLimited = L4_MABX_P.BRK_PRESS_DEM_T_FILT_CTRL_ERROR;

    if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

      PositionFinalLimited = DeltaTime;

    }



    L4_MABX_B.MinMax1_h1 = PositionFinalLimited;



    /* End of MinMax: '<S135>/MinMax1' */



    /* Saturate: '<S135>/Saturation' */

    DeltaTime = L4_MABX_B.MinMax1_h1;

    Time56 = L4_MABX_P.Saturation_LowerSat;

    AccelerationAverage = L4_MABX_P.Saturation_UpperSat;

    if (DeltaTime > AccelerationAverage) {

      L4_MABX_B.Saturation_p = AccelerationAverage;

    } else if (DeltaTime < Time56) {

      L4_MABX_B.Saturation_p = Time56;

    } else {

      L4_MABX_B.Saturation_p = DeltaTime;

    }



    /* End of Saturate: '<S135>/Saturation' */



    /* Product: '<S135>/Divide' */

    L4_MABX_B.Divide_lm = L4_MABX_B.Subtract_jr / L4_MABX_B.Saturation_p;



    /* Product: '<S135>/Product2' */

    L4_MABX_B.Product2_kj = L4_MABX_B.Subtract_n * L4_MABX_B.Divide_lm;



    /* Sum: '<S135>/Subtract1' incorporates:

     *  Constant: '<S135>/Constant1'

     */

    L4_MABX_B.Subtract1_pm = L4_MABX_P.Constant1_Value_f - L4_MABX_B.Divide_lm;



    /* UnitDelay: '<S135>/Unit_Delay2' */

    L4_MABX_B.Unit_Delay2_d = L4_MABX_DW.Unit_Delay2_DSTATE_dy;



    /* Product: '<S135>/Product1' */

    L4_MABX_B.Product1_c3 = L4_MABX_B.Subtract1_pm * L4_MABX_B.Unit_Delay2_d;



    /* Sum: '<S135>/Add1' */

    L4_MABX_B.Add1_i1 = L4_MABX_B.Product2_kj + L4_MABX_B.Product1_c3;



    /* Outputs for Atomic SubSystem: '<S135>/If_Then_Else' */

    L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator_m, L4_MABX_B.Subtract_n,

                         L4_MABX_B.Add1_i1, &L4_MABX_B.If_Then_Else_ly);



    /* End of Outputs for SubSystem: '<S135>/If_Then_Else' */



    /* RelationalOperator: '<S120>/Compare' incorporates:

     *  Constant: '<S120>/Constant'

     */

    L4_MABX_B.Compare_aa = (L4_MABX_B.Abs1_ap >

      L4_MABX_P.CompareToConstant1_const);



    /* Outputs for Enabled SubSystem: '<S112>/Calculate_D_term' */



    /* Constant: '<S102>/BRK_PRESS_DEM_KD_APV' incorporates:

     *  Constant: '<S102>/BRK_PRESS_DEM_T_FILT_D_APV'

     */

    L4_MABX_Calculate_D_term(L4_MABX_B.Compare_aa,

      L4_MABX_P.BRK_PRESS_DEM_KD_APV_Value, L4_MABX_B.Subtract_jr,

      L4_MABX_B.LogicalOperator1_ax, L4_MABX_B.If_Then_Else_ly.Switch,

      L4_MABX_P.BRK_PRESS_DEM_T_FILT_D_APV_Valu, &L4_MABX_B.Calculate_D_term,

      &L4_MABX_DW.Calculate_D_term, &L4_MABX_P.Calculate_D_term);



    /* End of Outputs for SubSystem: '<S112>/Calculate_D_term' */



    /* Product: '<S118>/Product' incorporates:

     *  Constant: '<S102>/BRK_PRESS_DEM_KP_APV'

     */

    L4_MABX_B.Product_iq = L4_MABX_P.BRK_PRESS_DEM_KP_APV_Value *

      L4_MABX_B.If_Then_Else_ly.Switch;



    /* UnitDelay: '<S110>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_ja = L4_MABX_DW.Unit_Delay_DSTATE_i2;



    /* RelationalOperator: '<S119>/Compare' incorporates:

     *  Constant: '<S119>/Constant'

     */

    L4_MABX_B.Compare_jrp = (L4_MABX_B.Abs_k4 >

      L4_MABX_P.CompareToConstant_const);



    /* Outputs for Enabled SubSystem: '<S112>/Calculate_I_term' */



    /* Constant: '<S102>/BRK_PRESS_DEM_KI_APV' incorporates:

     *  Constant: '<S102>/BRK_PRESS_DEM_AW_COND_INT_APV'

     *  Constant: '<S102>/BRK_PRESS_DEM_AW_HYSTERESIS_APV'

     *  Constant: '<S102>/CPV1'

     *  Constant: '<S102>/CPV3'

     */

    L4_MABX_Calculate_I_term(L4_MABX_B.Compare_jrp, L4_MABX_B.Product_iq,

      L4_MABX_P.BRK_PRESS_DEM_KI_APV_Value, L4_MABX_B.Brake_appl_percent,

      L4_MABX_B.If_Then_Else_ly.Switch, L4_MABX_B.LogicalOperator1_ax,

      L4_MABX_B.Subtract_jr, L4_MABX_P.CPV3_Value,

      L4_MABX_P.BRK_PRESS_DEM_AW_COND_INT_APV_V,

      L4_MABX_P.BRK_PRESS_DEM_AW_HYSTERESIS_APV, L4_MABX_P.CPV1_Value_g,

      L4_MABX_B.Unit_Delay_ja, &L4_MABX_B.Calculate_I_term,

      &L4_MABX_DW.Calculate_I_term, &L4_MABX_P.Calculate_I_term);



    /* End of Outputs for SubSystem: '<S112>/Calculate_I_term' */



    /* RelationalOperator: '<S138>/min_relop' incorporates:

     *  Constant: '<S102>/CPV4'

     *  Constant: '<S138>/min_val'

     */

    L4_MABX_B.min_relop_p = (L4_MABX_P.CheckStaticLowerBound_min <=

      L4_MABX_P.CPV4_Value);



    /* Assertion: '<S138>/Assertion' */

    utAssert(L4_MABX_B.min_relop_p);



    /* Sum: '<S114>/Add' incorporates:

     *  Constant: '<S102>/CPV3'

     */

    L4_MABX_B.Add_e = ((L4_MABX_B.Product_iq +

                        L4_MABX_B.Calculate_I_term.If_Then_Else.Switch) +

                       L4_MABX_B.Calculate_D_term.Subtract) +

      L4_MABX_P.CPV3_Value;



    /* RelationalOperator: '<S141>/Relational Operator1' incorporates:

     *  Constant: '<S102>/CPV6'

     */

    L4_MABX_B.RelationalOperator1_gi = (L4_MABX_B.Add_e >= L4_MABX_P.CPV6_Value);



    /* RelationalOperator: '<S141>/Relational Operator' incorporates:

     *  Constant: '<S102>/CPV'

     */

    L4_MABX_B.RelationalOperator_b = (L4_MABX_B.Add_e <= L4_MABX_P.CPV_Value);



    /* Outputs for Atomic SubSystem: '<S141>/If_Then_Else1' */



    /* Constant: '<S102>/CPV' */

    L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator_b, L4_MABX_P.CPV_Value,

                         L4_MABX_B.Add_e, &L4_MABX_B.If_Then_Else1_bq);



    /* End of Outputs for SubSystem: '<S141>/If_Then_Else1' */



    /* Outputs for Atomic SubSystem: '<S141>/If_Then_Else' */



    /* Constant: '<S102>/CPV6' */

    L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator1_gi, L4_MABX_P.CPV6_Value,

                         L4_MABX_B.If_Then_Else1_bq.Switch,

                         &L4_MABX_B.If_Then_Else_nj);



    /* End of Outputs for SubSystem: '<S141>/If_Then_Else' */

  } else {

    if (L4_MABX_DW.Bendix_2C2_brake_application_pr) {

      /* Disable for Enabled SubSystem: '<S112>/Calculate_D_term' */

      if (L4_MABX_DW.Calculate_D_term.Calculate_D_term_MODE) {

        L4_Calculate_D_term_Disable(&L4_MABX_B.Calculate_D_term,

          &L4_MABX_DW.Calculate_D_term, &L4_MABX_P.Calculate_D_term);

      }



      /* End of Disable for SubSystem: '<S112>/Calculate_D_term' */



      /* Disable for Enabled SubSystem: '<S112>/Calculate_I_term' */

      if (L4_MABX_DW.Calculate_I_term.Calculate_I_term_MODE) {

        L4_Calculate_I_term_Disable(&L4_MABX_B.Calculate_I_term,

          &L4_MABX_DW.Calculate_I_term, &L4_MABX_P.Calculate_I_term);

      }



      /* End of Disable for SubSystem: '<S112>/Calculate_I_term' */



      /* Disable for Outport: '<S102>/PID_output' */

      L4_MABX_B.If_Then_Else_nj.Switch = L4_MABX_P.PID_output_Y0;

      L4_MABX_DW.Bendix_2C2_brake_application_pr = false;

    }

  }



  /* End of Outputs for SubSystem: '<S77>/Bendix_2C2_brake_application_pressure_feedback_controller' */



  /* RelationalOperator: '<S393>/Compare' incorporates:

   *  Constant: '<S393>/Constant'

   */

  L4_MABX_B.Compare_ey = (L4_MABX_B.SFunction1_o4_lj ==

    L4_MABX_P.CompareToConstant9_const);



  /* RelationalOperator: '<S390>/Compare' incorporates:

   *  Constant: '<S390>/Constant'

   */

  L4_MABX_B.Compare_jb = (L4_MABX_B.SFunction1_o5_i ==

    L4_MABX_P.CompareToConstant10_const);



  /* RelationalOperator: '<S391>/Compare' incorporates:

   *  Constant: '<S391>/Constant'

   */

  L4_MABX_B.Compare_hc = (L4_MABX_B.SFunction1_o6_d ==

    L4_MABX_P.CompareToConstant11_const);



  /* RelationalOperator: '<S392>/Compare' incorporates:

   *  Constant: '<S392>/Constant'

   */

  L4_MABX_B.Compare_bp = (L4_MABX_B.SFunction1_o7_h ==

    L4_MABX_P.CompareToConstant12_const);



  /* Logic: '<S353>/Logical Operator2' */

  L4_MABX_B.LogicalOperator2_f = (L4_MABX_B.Compare_ey || L4_MABX_B.Compare_jb ||

    L4_MABX_B.Compare_hc || L4_MABX_B.Compare_bp);



  /* UnitDelay: '<S395>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_o = L4_MABX_DW.Unit_Delay_DSTATE_cx;



  /* Logic: '<S395>/Logical Operator1' */

  L4_MABX_B.LogicalOperator1_j = !L4_MABX_B.Unit_Delay_o;



  /* Logic: '<S395>/Logical Operator' */

  L4_MABX_B.LogicalOperator_f = (L4_MABX_B.LogicalOperator2_f &&

    L4_MABX_B.LogicalOperator1_j);



  /* UnitDelay: '<S396>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_jz = L4_MABX_DW.Unit_Delay_DSTATE_d0;



  /* Logic: '<S396>/Logical Operator1' */

  L4_MABX_B.LogicalOperator1_ao = (L4_MABX_B.LogicalOperator_f ||

    L4_MABX_B.Unit_Delay_jz);



  /* UnitDelay: '<S353>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_k4 = L4_MABX_DW.Unit_Delay_DSTATE_e;



  /* MinMax: '<S353>/MinMax' */

  DeltaTime = L4_MABX_B.Unit_Delay_k4;

  PositionFinalLimited = L4_MABX_B.SFunction1_o1_gd;

  if ((DeltaTime < PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax_d = PositionFinalLimited;



  /* End of MinMax: '<S353>/MinMax' */



  /* Outputs for Atomic SubSystem: '<S353>/If_Then_Else4' */



  /* Constant: '<S353>/STABILITY_ACTIVE_VSPD_TARGET_APV' incorporates:

   *  Constant: '<S353>/Constant4'

   */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator2_f,

                       L4_MABX_P.STABILITY_ACTIVE_VSPD_TARGET_AP,

                       L4_MABX_P.Constant4_Value_n, &L4_MABX_B.If_Then_Else4_h);



  /* End of Outputs for SubSystem: '<S353>/If_Then_Else4' */



  /* UnitDelay: '<S400>/FixPt Unit Delay2' */

  L4_MABX_B.FixPtUnitDelay2_b = L4_MABX_DW.FixPtUnitDelay2_DSTATE_aq;



  /* UnitDelay: '<S400>/FixPt Unit Delay1' */

  L4_MABX_B.Xold_h = L4_MABX_DW.FixPtUnitDelay1_DSTATE_h;



  /* Switch: '<S400>/Init' */

  if (L4_MABX_B.FixPtUnitDelay2_b != 0) {

    L4_MABX_B.Init_ip = L4_MABX_B.If_Then_Else4_h.Switch;

  } else {

    L4_MABX_B.Init_ip = L4_MABX_B.Xold_h;

  }



  /* End of Switch: '<S400>/Init' */



  /* Abs: '<S396>/Abs' incorporates:

   *  Constant: '<S353>/STABILITY_CTRL_SLEW_INC_APV'

   */

  L4_MABX_B.Abs_e = fabs(L4_MABX_P.STABILITY_CTRL_SLEW_INC_APV_Val);



  /* DigitalClock: '<S397>/Digital Clock' */

  L4_MABX_B.DigitalClock = L4_MABX_M->Timing.t[0];



  /* UnitDelay: '<S397>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_d = L4_MABX_DW.Unit_Delay_DSTATE_m;



  /* Sum: '<S397>/Subtract' */

  L4_MABX_B.Subtract_l = L4_MABX_B.DigitalClock - L4_MABX_B.Unit_Delay_d;



  /* Product: '<S396>/Product1' */

  L4_MABX_B.Product1_hp = L4_MABX_B.Abs_e * L4_MABX_B.Subtract_l;



  /* Sum: '<S396>/Add1' */

  L4_MABX_B.Add1_n = L4_MABX_B.Init_ip + L4_MABX_B.Product1_hp;



  /* MinMax: '<S396>/MinMax2' */

  DeltaTime = L4_MABX_B.If_Then_Else4_h.Switch;

  PositionFinalLimited = L4_MABX_B.Add1_n;

  if ((DeltaTime < PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax2_g = PositionFinalLimited;



  /* End of MinMax: '<S396>/MinMax2' */



  /* Abs: '<S396>/Abs1' incorporates:

   *  Constant: '<S353>/STABILITY_CTRL_SLEW_DEC_APV'

   */

  L4_MABX_B.Abs1_h = fabs(L4_MABX_P.STABILITY_CTRL_SLEW_DEC_APV_Val);



  /* Product: '<S396>/Product2' */

  L4_MABX_B.Product2_c = L4_MABX_B.Subtract_l * L4_MABX_B.Abs1_h;



  /* Sum: '<S396>/Subtract1' */

  L4_MABX_B.Subtract1_n = L4_MABX_B.Init_ip - L4_MABX_B.Product2_c;



  /* MinMax: '<S396>/MinMax1' */

  DeltaTime = L4_MABX_B.MinMax2_g;

  PositionFinalLimited = L4_MABX_B.Subtract1_n;

  if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax1_h = PositionFinalLimited;



  /* End of MinMax: '<S396>/MinMax1' */



  /* Outputs for Atomic SubSystem: '<S396>/If_Then_Else' */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator1_ao, L4_MABX_B.MinMax_d,

                       L4_MABX_B.MinMax1_h, &L4_MABX_B.If_Then_Else_m4);



  /* End of Outputs for SubSystem: '<S396>/If_Then_Else' */



  /* RelationalOperator: '<S381>/Compare' incorporates:

   *  Constant: '<S381>/Constant'

   */

  L4_MABX_B.Compare_d = (L4_MABX_B.ACCDistanceAlertSignal ==

    L4_MABX_P.CompareToConstant3_const);



  /* RelationalOperator: '<S382>/Compare' incorporates:

   *  Constant: '<S382>/Constant'

   */

  L4_MABX_B.Compare_dv = (L4_MABX_B.ForwardCollisionWarning ==

    L4_MABX_P.CompareToConstant8_const);



  /* Logic: '<S351>/Logical Operator1' */

  L4_MABX_B.LogicalOperator1_gm = (L4_MABX_B.Compare_d || L4_MABX_B.Compare_dv);



  /* UnitDelay: '<S384>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_hz = L4_MABX_DW.Unit_Delay_DSTATE_iy;



  /* Logic: '<S384>/Logical Operator1' */

  L4_MABX_B.LogicalOperator1_jp = !L4_MABX_B.Unit_Delay_hz;



  /* Logic: '<S384>/Logical Operator' */

  L4_MABX_B.LogicalOperator_kf = (L4_MABX_B.LogicalOperator1_gm &&

    L4_MABX_B.LogicalOperator1_jp);



  /* UnitDelay: '<S385>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_c = L4_MABX_DW.Unit_Delay_DSTATE_mv;



  /* Logic: '<S385>/Logical Operator1' */

  L4_MABX_B.LogicalOperator1_l4 = (L4_MABX_B.LogicalOperator_kf ||

    L4_MABX_B.Unit_Delay_c);



  /* UnitDelay: '<S351>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_n = L4_MABX_DW.Unit_Delay_DSTATE_g;



  /* MinMax: '<S351>/MinMax' */

  DeltaTime = L4_MABX_B.Unit_Delay_n;

  PositionFinalLimited = L4_MABX_B.SFunction1_o1_gd;

  if ((DeltaTime < PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax_nx = PositionFinalLimited;



  /* End of MinMax: '<S351>/MinMax' */



  /* Outputs for Atomic SubSystem: '<S351>/If_Then_Else4' */



  /* Constant: '<S351>/FCW_ACTIVE_VSPD_TARGET_APV' incorporates:

   *  Constant: '<S351>/Constant4'

   */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator1_gm,

                       L4_MABX_P.FCW_ACTIVE_VSPD_TARGET_APV_Valu,

                       L4_MABX_P.Constant4_Value_b, &L4_MABX_B.If_Then_Else4_e);



  /* End of Outputs for SubSystem: '<S351>/If_Then_Else4' */



  /* UnitDelay: '<S389>/FixPt Unit Delay2' */

  L4_MABX_B.FixPtUnitDelay2_p = L4_MABX_DW.FixPtUnitDelay2_DSTATE_ip;



  /* UnitDelay: '<S389>/FixPt Unit Delay1' */

  L4_MABX_B.Xold_f = L4_MABX_DW.FixPtUnitDelay1_DSTATE_hq;



  /* Switch: '<S389>/Init' */

  if (L4_MABX_B.FixPtUnitDelay2_p != 0) {

    L4_MABX_B.Init_b = L4_MABX_B.If_Then_Else4_e.Switch;

  } else {

    L4_MABX_B.Init_b = L4_MABX_B.Xold_f;

  }



  /* End of Switch: '<S389>/Init' */



  /* Abs: '<S385>/Abs' incorporates:

   *  Constant: '<S351>/FCW_CTRL_SLEW_INC_APV'

   */

  L4_MABX_B.Abs_ez = fabs(L4_MABX_P.FCW_CTRL_SLEW_INC_APV_Value);



  /* DigitalClock: '<S386>/Digital Clock' */

  L4_MABX_B.DigitalClock_b = L4_MABX_M->Timing.t[0];



  /* UnitDelay: '<S386>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_nx = L4_MABX_DW.Unit_Delay_DSTATE_b;



  /* Sum: '<S386>/Subtract' */

  L4_MABX_B.Subtract_i = L4_MABX_B.DigitalClock_b - L4_MABX_B.Unit_Delay_nx;



  /* Product: '<S385>/Product1' */

  L4_MABX_B.Product1_i = L4_MABX_B.Abs_ez * L4_MABX_B.Subtract_i;



  /* Sum: '<S385>/Add1' */

  L4_MABX_B.Add1_b = L4_MABX_B.Init_b + L4_MABX_B.Product1_i;



  /* MinMax: '<S385>/MinMax2' */

  DeltaTime = L4_MABX_B.If_Then_Else4_e.Switch;

  PositionFinalLimited = L4_MABX_B.Add1_b;

  if ((DeltaTime < PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax2_k = PositionFinalLimited;



  /* End of MinMax: '<S385>/MinMax2' */



  /* Abs: '<S385>/Abs1' incorporates:

   *  Constant: '<S351>/FCW_CTRL_SLEW_DEC_APV'

   */

  L4_MABX_B.Abs1_c = fabs(L4_MABX_P.FCW_CTRL_SLEW_DEC_APV_Value);



  /* Product: '<S385>/Product2' */

  L4_MABX_B.Product2_n = L4_MABX_B.Subtract_i * L4_MABX_B.Abs1_c;



  /* Sum: '<S385>/Subtract1' */

  L4_MABX_B.Subtract1_h = L4_MABX_B.Init_b - L4_MABX_B.Product2_n;



  /* MinMax: '<S385>/MinMax1' */

  DeltaTime = L4_MABX_B.MinMax2_k;

  PositionFinalLimited = L4_MABX_B.Subtract1_h;

  if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax1_jm = PositionFinalLimited;



  /* End of MinMax: '<S385>/MinMax1' */



  /* Outputs for Atomic SubSystem: '<S385>/If_Then_Else' */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator1_l4, L4_MABX_B.MinMax_nx,

                       L4_MABX_B.MinMax1_jm, &L4_MABX_B.If_Then_Else_bf);



  /* End of Outputs for SubSystem: '<S385>/If_Then_Else' */



  /* RateTransition: '<S81>/TmpRTBAtSignal Conversion3Inport1' */

  if (L4_MABX_M->Timing.RateInteraction.TID0_1 == 1) {

    L4_MABX_B.pathSpdLimit_a = L4_MABX_DW.TmpRTBAtSignalConversion3Inport;

  }



  /* MultiPortSwitch: '<S81>/Multiport Switch' incorporates:

   *  Constant: '<S81>/LONG_SPEED_SRC_SELECTOR_APV'

   */

  switch (LONG_SPEED_SRC_SELECTOR_APV) {

   case ENUM_LONG_SPEED_DEMAND_SOURCE_T_GPS_PATH:

    /* SignalConversion: '<S81>/Signal Conversion3' */

    L4_MABX_B.Vehicle_speed_abs_max_e = L4_MABX_B.pathSpdLimit_a;

    L4_MABX_B.Vehicle_speed_abs_max = L4_MABX_B.Vehicle_speed_abs_max_e;

    break;



   case ENUM_LONG_SPEED_DEMAND_SOURCE_T_OVERRIDE:

    /* SignalConversion: '<S81>/Signal Conversion8' incorporates:

     *  Constant: '<S81>/VSPD_ABS_MAX_APV'

     */

    L4_MABX_B.Vehicle_speed_abs_max_j = L4_MABX_P.VSPD_ABS_MAX_APV_Value;

    L4_MABX_B.Vehicle_speed_abs_max = L4_MABX_B.Vehicle_speed_abs_max_j;

    break;



   default:

    /* SignalConversion: '<S81>/Signal Conversion15' incorporates:

     *  Constant: '<S81>/CPV1'

     */

    L4_MABX_B.Vehicle_speed_abs_max_g = L4_MABX_P.CPV1_Value;

    L4_MABX_B.Vehicle_speed_abs_max = L4_MABX_B.Vehicle_speed_abs_max_g;

    break;

  }



  /* RelationalOperator: '<S347>/Compare' incorporates:

   *  Constant: '<S347>/Constant'

   */

  L4_MABX_B.Compare_jr = (L4_MABX_B.SFunction1_o7_g ==

    L4_MABX_P.Constant_Value_a);



  /* RateTransition: '<S81>/TmpRTBAtSignal Conversion2Inport1' */

  if (L4_MABX_M->Timing.RateInteraction.TID0_1 == 1) {

    L4_MABX_B.distance_o = L4_MABX_DW.TmpRTBAtSignalConversion2Inport;

  }



  /* MultiPortSwitch: '<S81>/Multiport Switch' incorporates:

   *  Constant: '<S81>/LONG_SPEED_SRC_SELECTOR_APV'

   */

  switch (LONG_SPEED_SRC_SELECTOR_APV) {

   case ENUM_LONG_SPEED_DEMAND_SOURCE_T_GPS_PATH:

    /* SignalConversion: '<S81>/Signal Conversion2' */

    L4_MABX_B.Distance_to_achieve_speed_tar_f = L4_MABX_B.distance_o;

    L4_MABX_B.Distance_to_achieve_speed_targe =

      L4_MABX_B.Distance_to_achieve_speed_tar_f;

    break;



   case ENUM_LONG_SPEED_DEMAND_SOURCE_T_OVERRIDE:

    /* SignalConversion: '<S81>/Signal Conversion7' incorporates:

     *  Constant: '<S81>/DISTANCE_M'

     */

    L4_MABX_B.Distance_to_achieve_speed_tar_j = DISTANCE_M;

    L4_MABX_B.Distance_to_achieve_speed_targe =

      L4_MABX_B.Distance_to_achieve_speed_tar_j;

    break;



   default:

    /* SignalConversion: '<S81>/Signal Conversion14' incorporates:

     *  Constant: '<S81>/CPV'

     */

    L4_MABX_B.Distance_to_achieve_speed_tar_m = L4_MABX_P.CPV_Value_ia;

    L4_MABX_B.Distance_to_achieve_speed_targe =

      L4_MABX_B.Distance_to_achieve_speed_tar_m;

    break;

  }



  /* UnitDelay: '<S348>/Delay Input1' */

  L4_MABX_B.Uk1[0] = L4_MABX_DW.DelayInput1_DSTATE[0];

  L4_MABX_B.Uk1[1] = L4_MABX_DW.DelayInput1_DSTATE[1];



  /* RelationalOperator: '<S348>/FixPt Relational Operator' */

  L4_MABX_B.FixPtRelationalOperator_d[0] =

    (L4_MABX_B.Distance_to_achieve_speed_targe != L4_MABX_B.Uk1[0]);

  L4_MABX_B.FixPtRelationalOperator_d[1] = (L4_MABX_B.Vehicle_speed_target_o !=

    L4_MABX_B.Uk1[1]);



  /* Logic: '<S81>/Logical Operator1' */

  L4_MABX_B.LogicalOperator1_ja = (L4_MABX_B.FixPtRelationalOperator_d[0] ||

    L4_MABX_B.FixPtRelationalOperator_d[1]);



  /* Saturate: '<S350>/Saturation5' */

  DeltaTime = L4_MABX_B.SFunction1_o1_gd;

  Time56 = L4_MABX_P.Saturation5_LowerSat;

  AccelerationAverage = L4_MABX_P.Saturation5_UpperSat;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Saturation5 = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Saturation5 = Time56;

  } else {

    L4_MABX_B.Saturation5 = DeltaTime;

  }



  /* End of Saturate: '<S350>/Saturation5' */



  /* MinMax: '<S350>/MinMax6' incorporates:

   *  Constant: '<S350>/MIN_VSPD_SIGMOID_INITIAL_KPH_APV'

   */

  DeltaTime = L4_MABX_B.Saturation5;

  PositionFinalLimited = L4_MABX_P.MIN_VSPD_SIGMOID_INITIAL_KPH_AP;

  if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax6 = PositionFinalLimited;



  /* End of MinMax: '<S350>/MinMax6' */



  /* Gain: '<S350>/Gain1' */

  L4_MABX_B.Gain1_e = L4_MABX_P.Gain1_Gain_a * L4_MABX_B.MinMax6;



  /* Saturate: '<S350>/Saturation4' */

  DeltaTime = L4_MABX_B.Vehicle_speed_target_o;

  Time56 = L4_MABX_P.Saturation4_LowerSat;

  AccelerationAverage = L4_MABX_P.Saturation4_UpperSat;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.VSPD_TARGET_KPH_APV_gu = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.VSPD_TARGET_KPH_APV_gu = Time56;

  } else {

    L4_MABX_B.VSPD_TARGET_KPH_APV_gu = DeltaTime;

  }



  /* End of Saturate: '<S350>/Saturation4' */



  /* MinMax: '<S350>/MinMax1' incorporates:

   *  Constant: '<S350>/MIN_VSPD_SIGMOID_FINAL_KPH_APV'

   */

  DeltaTime = L4_MABX_B.VSPD_TARGET_KPH_APV_gu;

  PositionFinalLimited = L4_MABX_P.MIN_VSPD_SIGMOID_FINAL_KPH_APV_;

  if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax1_f = PositionFinalLimited;



  /* End of MinMax: '<S350>/MinMax1' */



  /* Gain: '<S350>/Gain2' */

  L4_MABX_B.Gain2 = L4_MABX_P.Gain2_Gain_k * L4_MABX_B.MinMax1_f;



  /* Saturate: '<S350>/Saturation6' */

  DeltaTime = SPN1810_LongitudinalAcceleration;

  Time56 = L4_MABX_P.Saturation6_LowerSat;

  AccelerationAverage = L4_MABX_P.Saturation6_UpperSat;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Saturation6 = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Saturation6 = Time56;

  } else {

    L4_MABX_B.Saturation6 = DeltaTime;

  }



  /* End of Saturate: '<S350>/Saturation6' */



  /* MultiPortSwitch: '<S81>/Multiport Switch' incorporates:

   *  Constant: '<S81>/LONG_SPEED_SRC_SELECTOR_APV'

   */

  switch (LONG_SPEED_SRC_SELECTOR_APV) {

   case ENUM_LONG_SPEED_DEMAND_SOURCE_T_GPS_PATH:

    /* SignalConversion: '<S81>/Signal Conversion10' incorporates:

     *  Constant: '<S81>/CPV3'

     */

    L4_MABX_B.Acceleration_target_ms2_d = L4_MABX_P.CPV3_Value_l;

    L4_MABX_B.Acceleration_target_ms2 = L4_MABX_B.Acceleration_target_ms2_d;

    break;



   case ENUM_LONG_SPEED_DEMAND_SOURCE_T_OVERRIDE:

    /* SignalConversion: '<S81>/Signal Conversion5' incorporates:

     *  Constant: '<S81>/VEH_ACCEL_TARGET_APV'

     */

    L4_MABX_B.Acceleration_target_ms2_h = L4_MABX_P.VEH_ACCEL_TARGET_APV_Value;

    L4_MABX_B.Acceleration_target_ms2 = L4_MABX_B.Acceleration_target_ms2_h;

    break;



   default:

    /* SignalConversion: '<S81>/Signal Conversion11' incorporates:

     *  Constant: '<S81>/CPV2'

     */

    L4_MABX_B.Acceleration_target_ms2_f = L4_MABX_P.CPV2_Value;

    L4_MABX_B.Acceleration_target_ms2 = L4_MABX_B.Acceleration_target_ms2_f;

    break;

  }



  /* Saturate: '<S350>/Saturation7' */

  DeltaTime = L4_MABX_B.Acceleration_target_ms2;

  Time56 = L4_MABX_P.Saturation7_LowerSat;

  AccelerationAverage = L4_MABX_P.Saturation7_UpperSat;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Saturation7 = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Saturation7 = Time56;

  } else {

    L4_MABX_B.Saturation7 = DeltaTime;

  }



  /* End of Saturate: '<S350>/Saturation7' */



  /* Saturate: '<S350>/Saturation1' incorporates:

   *  Constant: '<S81>/VEH_JERK_INITIAL_APV'

   */

  DeltaTime = L4_MABX_P.VEH_JERK_INITIAL_APV_Value;

  Time56 = L4_MABX_P.Saturation1_LowerSat_b;

  AccelerationAverage = L4_MABX_P.Saturation1_UpperSat_o;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Saturation1 = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Saturation1 = Time56;

  } else {

    L4_MABX_B.Saturation1 = DeltaTime;

  }



  /* End of Saturate: '<S350>/Saturation1' */



  /* MultiPortSwitch: '<S81>/Multiport Switch' incorporates:

   *  Constant: '<S81>/LONG_SPEED_SRC_SELECTOR_APV'

   */

  switch (LONG_SPEED_SRC_SELECTOR_APV) {

   case ENUM_LONG_SPEED_DEMAND_SOURCE_T_GPS_PATH:

    /* SignalConversion: '<S81>/Signal Conversion13' incorporates:

     *  Constant: '<S81>/CPV4'

     */

    L4_MABX_B.Jerk_target_ms3_g = L4_MABX_P.CPV4_Value_k;

    L4_MABX_B.Jerk_target_ms3 = L4_MABX_B.Jerk_target_ms3_g;

    break;



   case ENUM_LONG_SPEED_DEMAND_SOURCE_T_OVERRIDE:

    /* SignalConversion: '<S81>/Signal Conversion6' incorporates:

     *  Constant: '<S81>/VEH_JERK_TARGET_APV'

     */

    L4_MABX_B.Jerk_target_ms3_d = L4_MABX_P.VEH_JERK_TARGET_APV_Value;

    L4_MABX_B.Jerk_target_ms3 = L4_MABX_B.Jerk_target_ms3_d;

    break;



   default:

    /* SignalConversion: '<S81>/Signal Conversion12' incorporates:

     *  Constant: '<S81>/CPV5'

     */

    L4_MABX_B.Jerk_target_ms3_l = L4_MABX_P.CPV5_Value_n;

    L4_MABX_B.Jerk_target_ms3 = L4_MABX_B.Jerk_target_ms3_l;

    break;

  }



  /* Saturate: '<S350>/Saturation2' */

  DeltaTime = L4_MABX_B.Jerk_target_ms3;

  Time56 = L4_MABX_P.Saturation2_LowerSat;

  AccelerationAverage = L4_MABX_P.Saturation2_UpperSat;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Saturation2 = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Saturation2 = Time56;

  } else {

    L4_MABX_B.Saturation2 = DeltaTime;

  }



  /* End of Saturate: '<S350>/Saturation2' */



  /* Chart: '<S350>/VehicleSpeedSetpointDynamicCalculation' */

  /* Gateway: Controller/L4_Controller/Task_10ms/Vehicle_speed_target/Determine_sigmoid_vehicle_speed_profile/VehicleSpeedSetpointDynamicCalculation */

  /* During: Controller/L4_Controller/Task_10ms/Vehicle_speed_target/Determine_sigmoid_vehicle_speed_profile/VehicleSpeedSetpointDynamicCalculation */

  /* Entry Internal: Controller/L4_Controller/Task_10ms/Vehicle_speed_target/Determine_sigmoid_vehicle_speed_profile/VehicleSpeedSetpointDynamicCalculation */

  /* Transition: '<S365>:88' */

  if (L4_MABX_B.LogicalOperator1_ja) {

    /* Transition: '<S365>:89' */

    /* Transition: '<S365>:39' */

    PositionFinalLimited = L4_MABX_B.Distance_to_achieve_speed_targe;

    if ((0.001 > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

      PositionFinalLimited = 0.001;

    }



    Time56 = L4_MABX_B.Gain1_e;

    if ((0.1 > Time56) || rtIsNaN(Time56)) {

      L4_MABX_DW.VelocityInitialLimited = 0.1;

    } else {

      L4_MABX_DW.VelocityInitialLimited = Time56;

    }



    Time56 = L4_MABX_B.Gain2;

    if ((0.1 > Time56) || rtIsNaN(Time56)) {

      L4_MABX_DW.VelocityFinalLimited = 0.1;

    } else {

      L4_MABX_DW.VelocityFinalLimited = Time56;

    }



    L4_MABX_DW.TimeFinal = 2.0 * PositionFinalLimited /

      (L4_MABX_DW.VelocityInitialLimited + L4_MABX_DW.VelocityFinalLimited);

    Time56 = L4_MABX_DW.TimeFinal;

    if ((0.007 > Time56) || rtIsNaN(Time56)) {

      L4_MABX_DW.TimeFinal = 0.007;

    } else {

      L4_MABX_DW.TimeFinal = Time56;

    }



    AccelerationAverage = (L4_MABX_DW.VelocityFinalLimited -

      L4_MABX_DW.VelocityInitialLimited) / L4_MABX_DW.TimeFinal;

    L4_MABX_DW.TimeFinal *= 2.0;

    if (L4_MABX_DW.VelocityFinalLimited > L4_MABX_DW.VelocityInitialLimited) {

      /* Transition: '<S365>:238' */

      /* Transition: '<S365>:240' */

      Time56 = L4_MABX_B.Saturation6;

      if ((AccelerationAverage < Time56) || rtIsNaN(Time56)) {

        Time56 = AccelerationAverage;

      }



      if ((0.0 > Time56) || rtIsNaN(Time56)) {

        L4_MABX_DW.AccelerationInitialLimited = 0.0;

      } else {

        L4_MABX_DW.AccelerationInitialLimited = Time56;

      }



      Time56 = L4_MABX_B.Saturation7;

      if ((AccelerationAverage < Time56) || rtIsNaN(Time56)) {

        Time56 = AccelerationAverage;

      }



      if ((0.0 > Time56) || rtIsNaN(Time56)) {

        L4_MABX_DW.AccelerationFinalLimited = 0.0;

      } else {

        L4_MABX_DW.AccelerationFinalLimited = Time56;

      }



      /* Transition: '<S365>:243' */

    } else {

      /* Transition: '<S365>:241' */

      Time56 = L4_MABX_B.Saturation6;

      if ((0.0 < Time56) || rtIsNaN(Time56)) {

        Time56 = 0.0;

      }



      if ((AccelerationAverage > Time56) || rtIsNaN(Time56)) {

        L4_MABX_DW.AccelerationInitialLimited = AccelerationAverage;

      } else {

        L4_MABX_DW.AccelerationInitialLimited = Time56;

      }



      Time56 = L4_MABX_B.Saturation7;

      if ((0.0 < Time56) || rtIsNaN(Time56)) {

        Time56 = 0.0;

      }



      if ((AccelerationAverage > Time56) || rtIsNaN(Time56)) {

        L4_MABX_DW.AccelerationFinalLimited = AccelerationAverage;

      } else {

        L4_MABX_DW.AccelerationFinalLimited = Time56;

      }

    }



    /* Transition: '<S365>:16' */

    DeltaTimeFinal = L4_MABX_DW.TimeFinal;

    for (starting_index = 1U; starting_index < 16; starting_index++) {

      /* Transition: '<S365>:14' */

      /* Transition: '<S365>:201' */

      DeltaTime = ((L4_MABX_DW.VelocityInitialLimited -

                    L4_MABX_DW.VelocityFinalLimited) +

                   L4_MABX_DW.AccelerationFinalLimited * L4_MABX_DW.TimeFinal) *

        2.0 / (L4_MABX_DW.TimeFinal * L4_MABX_DW.TimeFinal);

      if (L4_MABX_DW.VelocityFinalLimited > L4_MABX_DW.VelocityInitialLimited) {

        /* Transition: '<S365>:121' */

        /* Transition: '<S365>:116' */

        L4_MABX_DW.Jerk12 = L4_MABX_B.Saturation1;

        DeltaTime = fabs(DeltaTime);

        Time56 = L4_MABX_B.Saturation2;

        if ((DeltaTime > Time56) || rtIsNaN(Time56)) {

          Time56 = DeltaTime;

        }



        L4_MABX_DW.Jerk56 = -Time56;



        /* Transition: '<S365>:120' */

      } else {

        /* Transition: '<S365>:122' */

        L4_MABX_DW.Jerk12 = -L4_MABX_B.Saturation1;

        DeltaTime = fabs(DeltaTime);

        Time56 = L4_MABX_B.Saturation2;

        if ((DeltaTime > Time56) || rtIsNaN(Time56)) {

          L4_MABX_DW.Jerk56 = DeltaTime;

        } else {

          L4_MABX_DW.Jerk56 = Time56;

        }

      }



      /* Transition: '<S365>:275' */

      L4_MABX_CalculateAcceleration34();

      if (fabs(L4_MABX_DW.Acceleration34 - AccelerationAverage) < 0.001) {

        /* Transition: '<S365>:141' */

        /* Transition: '<S365>:145' */

        L4_MABX_B.TimeVectorRaw[0] = 0.0;

        L4_MABX_B.TimeVectorRaw[1] = 0.001;

        L4_MABX_B.TimeVectorRaw[2] = 0.003;

        L4_MABX_B.TimeVectorRaw[3] = (L4_MABX_DW.TimeFinal - 0.002) - 0.001;

        L4_MABX_B.TimeVectorRaw[4] = (L4_MABX_DW.TimeFinal - 0.002) + 0.001;

        L4_MABX_B.TimeVectorRaw[5] = L4_MABX_DW.TimeFinal;

        for (i = 0; i < 6; i++) {

          L4_MABX_B.JerkVectorRaw[i] = 0.0;

        }



        L4_MABX_B.AccelerationVectorRaw[0] = AccelerationAverage;



        /* Transition: '<S365>:191' */

        /* Transition: '<S365>:303' */

      } else {

        /* Transition: '<S365>:298' */

        if (L4_MABX_DW.AlternateMethod) {

          /* Transition: '<S365>:300' */

          /* Transition: '<S365>:302' */

          Time56 = (L4_MABX_DW.AccelerationFinalLimited -

                    L4_MABX_DW.Acceleration34) / L4_MABX_DW.Jerk56;

          if ((0.002 > Time56) || rtIsNaN(Time56)) {

            Time56 = 0.002;

          }



          L4_MABX_B.TimeVectorRaw[0] = 0.0;

          L4_MABX_B.TimeVectorRaw[1] = 0.001;

          L4_MABX_B.TimeVectorRaw[2] = 0.003;

          L4_MABX_B.TimeVectorRaw[3] = (L4_MABX_DW.TimeFinal - Time56) - 0.001;

          L4_MABX_B.TimeVectorRaw[4] = (L4_MABX_DW.TimeFinal - Time56) + 0.001;

          L4_MABX_B.TimeVectorRaw[5] = L4_MABX_DW.TimeFinal;

          L4_MABX_B.JerkVectorRaw[0] = 0.0;

          L4_MABX_B.JerkVectorRaw[1] = 0.0;

          L4_MABX_B.JerkVectorRaw[2] = 0.0;

          L4_MABX_B.JerkVectorRaw[3] = 0.0;

          L4_MABX_B.JerkVectorRaw[4] = L4_MABX_DW.Jerk56;

          L4_MABX_B.JerkVectorRaw[5] = L4_MABX_DW.Jerk56;

          L4_MABX_B.AccelerationVectorRaw[0] = L4_MABX_DW.Acceleration34;



          /* Transition: '<S365>:303' */

        } else {

          /* Transition: '<S365>:157' */

          DeltaTime = (L4_MABX_DW.Acceleration34 -

                       L4_MABX_DW.AccelerationInitialLimited) /

            L4_MABX_DW.Jerk12;

          if ((0.002 > DeltaTime) || rtIsNaN(DeltaTime)) {

            DeltaTime = 0.002;

          }



          Time56 = (L4_MABX_DW.AccelerationFinalLimited -

                    L4_MABX_DW.Acceleration34) / L4_MABX_DW.Jerk56;

          if ((0.002 > Time56) || rtIsNaN(Time56)) {

            Time56 = 0.002;

          }



          L4_MABX_B.TimeVectorRaw[0] = 0.0;

          L4_MABX_B.TimeVectorRaw[1] = DeltaTime - 0.001;

          L4_MABX_B.TimeVectorRaw[2] = DeltaTime + 0.001;

          L4_MABX_B.TimeVectorRaw[3] = (L4_MABX_DW.TimeFinal - Time56) - 0.001;

          L4_MABX_B.TimeVectorRaw[4] = (L4_MABX_DW.TimeFinal - Time56) + 0.001;

          L4_MABX_B.TimeVectorRaw[5] = L4_MABX_DW.TimeFinal;

          L4_MABX_B.JerkVectorRaw[0] = L4_MABX_DW.Jerk12;

          L4_MABX_B.JerkVectorRaw[1] = L4_MABX_DW.Jerk12;

          L4_MABX_B.JerkVectorRaw[2] = 0.0;

          L4_MABX_B.JerkVectorRaw[3] = 0.0;

          L4_MABX_B.JerkVectorRaw[4] = L4_MABX_DW.Jerk56;

          L4_MABX_B.JerkVectorRaw[5] = L4_MABX_DW.Jerk56;

          L4_MABX_B.AccelerationVectorRaw[0] =

            L4_MABX_DW.AccelerationInitialLimited;

        }

      }



      /* Transition: '<S365>:29' */

      L4_MABX_B.VelocityVectorRaw[0] = L4_MABX_DW.VelocityInitialLimited;

      L4_MABX_B.PositionVectorRaw[0] = 0.0;

      for (j = 2U; j < 7; j++) {

        /* Transition: '<S365>:34' */

        /* Transition: '<S365>:36' */

        DeltaTime = L4_MABX_B.TimeVectorRaw[j - 1] - L4_MABX_B.TimeVectorRaw[j -

          2];

        L4_MABX_B.AccelerationVectorRaw[j - 1] = L4_MABX_B.JerkVectorRaw[j - 2] *

          DeltaTime + L4_MABX_B.AccelerationVectorRaw[j - 2];

        L4_MABX_B.VelocityVectorRaw[j - 1] = (L4_MABX_B.AccelerationVectorRaw[j

          - 2] * DeltaTime + L4_MABX_B.VelocityVectorRaw[j - 2]) +

          L4_MABX_B.JerkVectorRaw[j - 2] * 0.5 * (DeltaTime * DeltaTime);

        L4_MABX_B.PositionVectorRaw[j - 1] = ((L4_MABX_B.VelocityVectorRaw[j - 2]

          * DeltaTime + L4_MABX_B.PositionVectorRaw[j - 2]) +

          L4_MABX_B.AccelerationVectorRaw[j - 2] * 0.5 * (DeltaTime * DeltaTime))

          + L4_MABX_B.JerkVectorRaw[j - 2] / 6.0 * rt_powd_snf(DeltaTime, 3.0);



        /* Transition: '<S365>:33' */

      }



      /* Transition: '<S365>:37' */

      DeltaTimeFinal *= 0.5;

      if ((L4_MABX_B.PositionVectorRaw[5] - PositionFinalLimited < 0.0) &&

          (L4_MABX_B.VelocityVectorRaw[5] > 0.0)) {

        /* Transition: '<S365>:61' */

        /* Transition: '<S365>:62' */

        L4_MABX_DW.TimeFinal += DeltaTimeFinal;



        /* Transition: '<S365>:64' */

      } else {

        /* Transition: '<S365>:63' */

        L4_MABX_DW.TimeFinal -= DeltaTimeFinal;

      }



      /* Transition: '<S365>:60' */

      Time56 = L4_MABX_DW.TimeFinal;

      if ((0.007 > Time56) || rtIsNaN(Time56)) {

        L4_MABX_DW.TimeFinal = 0.007;

      } else {

        L4_MABX_DW.TimeFinal = Time56;

      }



      /* Transition: '<S365>:17' */

    }



    /* Transition: '<S365>:18' */

    /* Transition: '<S365>:91' */

  } else {

    /* Transition: '<S365>:90' */

  }



  /* End of Chart: '<S350>/VehicleSpeedSetpointDynamicCalculation' */



  /* Chart: '<S350>/TwentyPointVectorCalculation' */

  if (L4_MABX_B.LogicalOperator1_ja) {

    /* Transition: '<S364>:89' */

    /* Transition: '<S364>:39' */

    L4_MABX_B.TimeVector[0] = L4_MABX_B.TimeVectorRaw[0];

    L4_MABX_B.JerkVector[0] = L4_MABX_B.JerkVectorRaw[0];

    L4_MABX_B.AccelerationVector[0] = L4_MABX_B.AccelerationVectorRaw[0];

    L4_MABX_B.VelocityVector[0] = L4_MABX_B.VelocityVectorRaw[0];

    L4_MABX_B.PositionVector[0] = L4_MABX_B.PositionVectorRaw[0];

    PositionFinalLimited = (L4_MABX_B.TimeVectorRaw[1] -

      L4_MABX_B.TimeVectorRaw[0]) / 10.0;

    for (starting_index = 2U; starting_index < 11; starting_index++) {

      /* Transition: '<S364>:14' */

      /* Transition: '<S364>:101' */

      L4_MABX_B.TimeVector[starting_index - 1] =

        L4_MABX_B.TimeVector[starting_index - 2] + PositionFinalLimited;

      DeltaTime = L4_MABX_B.TimeVector[starting_index - 1] -

        L4_MABX_B.TimeVectorRaw[0];

      L4_MABX_B.JerkVector[starting_index - 1] = L4_MABX_B.JerkVectorRaw[0];

      L4_MABX_B.AccelerationVector[starting_index - 1] =

        L4_MABX_B.JerkVectorRaw[0] * DeltaTime +

        L4_MABX_B.AccelerationVectorRaw[0];

      L4_MABX_B.VelocityVector[starting_index - 1] =

        (L4_MABX_B.AccelerationVectorRaw[0] * DeltaTime +

         L4_MABX_B.VelocityVectorRaw[0]) + 0.5 * L4_MABX_B.JerkVectorRaw[0] *

        (DeltaTime * DeltaTime);

      L4_MABX_B.PositionVector[starting_index - 1] =

        ((L4_MABX_B.VelocityVectorRaw[0] * DeltaTime +

          L4_MABX_B.PositionVectorRaw[0]) + 0.5 *

         L4_MABX_B.AccelerationVectorRaw[0] * (DeltaTime * DeltaTime)) +

        L4_MABX_B.JerkVectorRaw[0] / 6.0 * rt_powd_snf(DeltaTime, 3.0);

      DeltaTime = L4_MABX_B.PositionVector[starting_index - 2] + 0.0001;

      Time56 = L4_MABX_B.PositionVector[starting_index - 1];

      if ((DeltaTime > Time56) || rtIsNaN(Time56)) {

        Time56 = DeltaTime;

      }



      L4_MABX_B.PositionVector[starting_index - 1] = Time56;



      /* Transition: '<S364>:17' */

    }



    /* Transition: '<S364>:110' */

    L4_MABX_B.TimeVector[10] = L4_MABX_B.TimeVectorRaw[1];

    L4_MABX_B.JerkVector[10] = L4_MABX_B.JerkVectorRaw[1];

    L4_MABX_B.AccelerationVector[10] = L4_MABX_B.AccelerationVectorRaw[1];

    L4_MABX_B.VelocityVector[10] = L4_MABX_B.VelocityVectorRaw[1];

    DeltaTime = L4_MABX_B.PositionVector[9] + 0.0001;

    Time56 = L4_MABX_B.PositionVectorRaw[1];

    if ((DeltaTime > Time56) || rtIsNaN(Time56)) {

      Time56 = DeltaTime;

    }



    L4_MABX_B.PositionVector[10] = Time56;

    L4_MABX_B.TimeVector[11] = L4_MABX_B.TimeVectorRaw[2];

    L4_MABX_B.JerkVector[11] = L4_MABX_B.JerkVectorRaw[2];

    L4_MABX_B.AccelerationVector[11] = L4_MABX_B.AccelerationVectorRaw[2];

    L4_MABX_B.VelocityVector[11] = L4_MABX_B.VelocityVectorRaw[2];

    DeltaTime = L4_MABX_B.PositionVector[10] + 0.0001;

    Time56 = L4_MABX_B.PositionVectorRaw[2];

    if ((DeltaTime > Time56) || rtIsNaN(Time56)) {

      Time56 = DeltaTime;

    }



    L4_MABX_B.PositionVector[11] = Time56;

    PositionFinalLimited = (L4_MABX_B.TimeVectorRaw[3] -

      L4_MABX_B.TimeVectorRaw[2]) / 10.0;

    for (starting_index = 13U; starting_index < 22; starting_index++) {

      /* Transition: '<S364>:127' */

      /* Transition: '<S364>:133' */

      L4_MABX_B.TimeVector[starting_index - 1] =

        L4_MABX_B.TimeVector[starting_index - 2] + PositionFinalLimited;

      DeltaTime = L4_MABX_B.TimeVector[starting_index - 1] -

        L4_MABX_B.TimeVectorRaw[2];

      L4_MABX_B.JerkVector[starting_index - 1] = L4_MABX_B.JerkVectorRaw[2];

      L4_MABX_B.AccelerationVector[starting_index - 1] =

        L4_MABX_B.JerkVectorRaw[2] * DeltaTime +

        L4_MABX_B.AccelerationVectorRaw[2];

      L4_MABX_B.VelocityVector[starting_index - 1] =

        (L4_MABX_B.AccelerationVectorRaw[2] * DeltaTime +

         L4_MABX_B.VelocityVectorRaw[2]) + 0.5 * L4_MABX_B.JerkVectorRaw[2] *

        (DeltaTime * DeltaTime);

      L4_MABX_B.PositionVector[starting_index - 1] =

        ((L4_MABX_B.VelocityVectorRaw[2] * DeltaTime +

          L4_MABX_B.PositionVectorRaw[2]) + 0.5 *

         L4_MABX_B.AccelerationVectorRaw[2] * (DeltaTime * DeltaTime)) +

        L4_MABX_B.JerkVectorRaw[2] / 6.0 * rt_powd_snf(DeltaTime, 3.0);

      DeltaTime = L4_MABX_B.PositionVector[starting_index - 2] + 0.0001;

      Time56 = L4_MABX_B.PositionVector[starting_index - 1];

      if ((DeltaTime > Time56) || rtIsNaN(Time56)) {

        Time56 = DeltaTime;

      }



      L4_MABX_B.PositionVector[starting_index - 1] = Time56;



      /* Transition: '<S364>:131' */

    }



    /* Transition: '<S364>:132' */

    L4_MABX_B.TimeVector[21] = L4_MABX_B.TimeVectorRaw[3];

    L4_MABX_B.JerkVector[21] = L4_MABX_B.JerkVectorRaw[3];

    L4_MABX_B.AccelerationVector[21] = L4_MABX_B.AccelerationVectorRaw[3];

    L4_MABX_B.VelocityVector[21] = L4_MABX_B.VelocityVectorRaw[3];

    DeltaTime = L4_MABX_B.PositionVector[20] + 0.0001;

    Time56 = L4_MABX_B.PositionVectorRaw[3];

    if ((DeltaTime > Time56) || rtIsNaN(Time56)) {

      Time56 = DeltaTime;

    }



    L4_MABX_B.PositionVector[21] = Time56;

    L4_MABX_B.TimeVector[22] = L4_MABX_B.TimeVectorRaw[4];

    L4_MABX_B.JerkVector[22] = L4_MABX_B.JerkVectorRaw[4];

    L4_MABX_B.AccelerationVector[22] = L4_MABX_B.AccelerationVectorRaw[4];

    L4_MABX_B.VelocityVector[22] = L4_MABX_B.VelocityVectorRaw[4];

    DeltaTime = L4_MABX_B.PositionVector[21] + 0.0001;

    Time56 = L4_MABX_B.PositionVectorRaw[4];

    if ((DeltaTime > Time56) || rtIsNaN(Time56)) {

      Time56 = DeltaTime;

    }



    L4_MABX_B.PositionVector[22] = Time56;

    PositionFinalLimited = (L4_MABX_B.TimeVectorRaw[5] -

      L4_MABX_B.TimeVectorRaw[4]) / 10.0;

    for (starting_index = 24U; starting_index < 33; starting_index++) {

      /* Transition: '<S364>:111' */

      /* Transition: '<S364>:113' */

      L4_MABX_B.TimeVector[starting_index - 1] =

        L4_MABX_B.TimeVector[starting_index - 2] + PositionFinalLimited;

      DeltaTime = L4_MABX_B.TimeVector[starting_index - 1] -

        L4_MABX_B.TimeVectorRaw[4];

      L4_MABX_B.JerkVector[starting_index - 1] = L4_MABX_B.JerkVectorRaw[4];

      L4_MABX_B.AccelerationVector[starting_index - 1] =

        L4_MABX_B.JerkVectorRaw[4] * DeltaTime +

        L4_MABX_B.AccelerationVectorRaw[4];

      L4_MABX_B.VelocityVector[starting_index - 1] =

        (L4_MABX_B.AccelerationVectorRaw[4] * DeltaTime +

         L4_MABX_B.VelocityVectorRaw[4]) + 0.5 * L4_MABX_B.JerkVectorRaw[4] *

        (DeltaTime * DeltaTime);

      L4_MABX_B.PositionVector[starting_index - 1] =

        ((L4_MABX_B.VelocityVectorRaw[4] * DeltaTime +

          L4_MABX_B.PositionVectorRaw[4]) + 0.5 *

         L4_MABX_B.AccelerationVectorRaw[4] * (DeltaTime * DeltaTime)) +

        L4_MABX_B.JerkVectorRaw[4] / 6.0 * rt_powd_snf(DeltaTime, 3.0);

      DeltaTime = L4_MABX_B.PositionVector[starting_index - 2] + 0.0001;

      Time56 = L4_MABX_B.PositionVector[starting_index - 1];

      if ((DeltaTime > Time56) || rtIsNaN(Time56)) {

        Time56 = DeltaTime;

      }



      L4_MABX_B.PositionVector[starting_index - 1] = Time56;



      /* Transition: '<S364>:112' */

    }



    /* Transition: '<S364>:114' */

    L4_MABX_B.TimeVector[32] = L4_MABX_B.TimeVectorRaw[5];

    L4_MABX_B.JerkVector[32] = L4_MABX_B.JerkVectorRaw[5];

    L4_MABX_B.AccelerationVector[32] = L4_MABX_B.AccelerationVectorRaw[5];

    L4_MABX_B.VelocityVector[32] = L4_MABX_B.VelocityVectorRaw[5];

    DeltaTime = L4_MABX_B.PositionVector[31] + 0.0001;

    Time56 = L4_MABX_B.PositionVectorRaw[5];

    if ((DeltaTime > Time56) || rtIsNaN(Time56)) {

      Time56 = DeltaTime;

    }



    L4_MABX_B.PositionVector[32] = Time56;



    /* Transition: '<S364>:141' */

  } else {

    /* Transition: '<S364>:90' */

  }



  /* End of Chart: '<S350>/TwentyPointVectorCalculation' */



  /* Gain: '<S350>/Gain3' */

  /* Transition: '<S365>:93' */

  /* Gateway: Controller/L4_Controller/Task_10ms/Vehicle_speed_target/Determine_sigmoid_vehicle_speed_profile/TwentyPointVectorCalculation */

  /* During: Controller/L4_Controller/Task_10ms/Vehicle_speed_target/Determine_sigmoid_vehicle_speed_profile/TwentyPointVectorCalculation */

  /* Entry Internal: Controller/L4_Controller/Task_10ms/Vehicle_speed_target/Determine_sigmoid_vehicle_speed_profile/TwentyPointVectorCalculation */

  /* Transition: '<S364>:88' */

  /* Transition: '<S364>:93' */

  for (i = 0; i < 33; i++) {

    L4_MABX_B.Vehicle_speed_vector_kph[i] = L4_MABX_P.Gain3_Gain_l *

      L4_MABX_B.VelocityVector[i];

  }



  /* End of Gain: '<S350>/Gain3' */



  /* RelationalOperator: '<S367>/Compare' incorporates:

   *  Constant: '<S367>/Constant'

   */

  for (i = 0; i < 33; i++) {

    L4_MABX_B.Compare_nk[i] = (L4_MABX_B.Vehicle_speed_vector_kph[i] <

      L4_MABX_P.Constant_Value_n);

  }



  /* End of RelationalOperator: '<S367>/Compare' */



  /* Logic: '<S362>/Logical Operator' */

  zcEvent = L4_MABX_B.Compare_nk[0];

  for (i = 0; i < 32; i++) {

    zcEvent = (zcEvent || L4_MABX_B.Compare_nk[i + 1]);

  }



  L4_MABX_B.f_vspd_output_less_than_zero = zcEvent;



  /* End of Logic: '<S362>/Logical Operator' */



  /* MinMax: '<S362>/MinMax3' */

  PositionFinalLimited = L4_MABX_B.Vehicle_speed_vector_kph[0];

  for (i = 0; i < 32; i++) {

    Time56 = L4_MABX_B.Vehicle_speed_vector_kph[i + 1];

    if (!((PositionFinalLimited < Time56) || rtIsNaN(Time56))) {

      PositionFinalLimited = Time56;

    }

  }



  L4_MABX_B.MinMax3 = PositionFinalLimited;



  /* End of MinMax: '<S362>/MinMax3' */



  /* UnitDelay: '<S366>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_f = L4_MABX_DW.Unit_Delay_DSTATE_bw;



  /* Outputs for Atomic SubSystem: '<S366>/If_Then_Else' */

  L4_MABX_If_Then_Else_g(L4_MABX_B.LogicalOperator1_ja, L4_MABX_B.Saturation5,

    L4_MABX_B.Unit_Delay_f, &L4_MABX_B.If_Then_Else_og);



  /* End of Outputs for SubSystem: '<S366>/If_Then_Else' */



  /* MinMax: '<S362>/MinMax5' */

  DeltaTime = L4_MABX_B.If_Then_Else_og.Switch;

  PositionFinalLimited = L4_MABX_B.VSPD_TARGET_KPH_APV_gu;

  if ((DeltaTime < PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax5 = PositionFinalLimited;



  /* End of MinMax: '<S362>/MinMax5' */



  /* Sum: '<S362>/Subtract' */

  L4_MABX_B.Subtract_al = L4_MABX_B.MinMax3 - L4_MABX_B.MinMax5;



  /* Abs: '<S362>/Abs' */

  L4_MABX_B.Abs_m = fabs(L4_MABX_B.Subtract_al);



  /* RelationalOperator: '<S362>/Relational Operator' incorporates:

   *  Constant: '<S362>/MIN_VSPD_DELTA_THRESHOLD_KPH_APV'

   */

  L4_MABX_B.RelationalOperator_f = (L4_MABX_B.Abs_m >

    L4_MABX_P.MIN_VSPD_DELTA_THRESHOLD_KPH_AP);



  /* Logic: '<S368>/Logical Operator3' incorporates:

   *  Constant: '<S362>/CPV'

   */

  L4_MABX_B.LogicalOperator3_o = !L4_MABX_P.CPV_Value_a;



  /* UnitDelay: '<S368>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_ag = L4_MABX_DW.Unit_Delay_DSTATE_ko;



  /* Logic: '<S368>/Logical Operator' */

  L4_MABX_B.LogicalOperator_ob = (L4_MABX_B.LogicalOperator3_o &&

    L4_MABX_B.Unit_Delay_ag);



  /* Logic: '<S368>/Logical Operator1' */

  L4_MABX_B.LogicalOperator1_ph = (L4_MABX_B.LogicalOperator1_ja ||

    L4_MABX_B.LogicalOperator_ob);



  /* Logic: '<S362>/Logical Operator2' */

  L4_MABX_B.f_vspd_min_delta_greater_than_t = (L4_MABX_B.RelationalOperator_f &&

    L4_MABX_B.LogicalOperator1_ph);



  /* MinMax: '<S362>/MinMax4' */

  PositionFinalLimited = L4_MABX_B.Vehicle_speed_vector_kph[0];

  for (i = 0; i < 32; i++) {

    Time56 = L4_MABX_B.Vehicle_speed_vector_kph[i + 1];

    if (!((PositionFinalLimited > Time56) || rtIsNaN(Time56))) {

      PositionFinalLimited = Time56;

    }

  }



  L4_MABX_B.MinMax4 = PositionFinalLimited;



  /* End of MinMax: '<S362>/MinMax4' */



  /* MinMax: '<S362>/MinMax6' */

  DeltaTime = L4_MABX_B.If_Then_Else_og.Switch;

  PositionFinalLimited = L4_MABX_B.VSPD_TARGET_KPH_APV_gu;

  if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax6_j = PositionFinalLimited;



  /* End of MinMax: '<S362>/MinMax6' */



  /* Sum: '<S362>/Subtract1' */

  L4_MABX_B.Subtract1_c = L4_MABX_B.MinMax4 - L4_MABX_B.MinMax6_j;



  /* Abs: '<S362>/Abs1' */

  L4_MABX_B.Abs1_h5 = fabs(L4_MABX_B.Subtract1_c);



  /* RelationalOperator: '<S362>/Relational Operator1' incorporates:

   *  Constant: '<S362>/MAX_VSPD_DELTA_THRESHOLD_KPH_APV'

   */

  L4_MABX_B.RelationalOperator1_g4j = (L4_MABX_B.Abs1_h5 >

    L4_MABX_P.MAX_VSPD_DELTA_THRESHOLD_KPH_AP);



  /* Logic: '<S362>/Logical Operator1' */

  L4_MABX_B.f_vspd_max_delta_greater_than_t = (L4_MABX_B.RelationalOperator1_g4j

    && L4_MABX_B.LogicalOperator1_ph);



  /* MinMax: '<S362>/MinMax8' */

  PositionFinalLimited = L4_MABX_B.AccelerationVector[0];

  for (i = 0; i < 32; i++) {

    Time56 = L4_MABX_B.AccelerationVector[i + 1];

    if (!((PositionFinalLimited > Time56) || rtIsNaN(Time56))) {

      PositionFinalLimited = Time56;

    }

  }



  L4_MABX_B.MinMax8 = PositionFinalLimited;



  /* End of MinMax: '<S362>/MinMax8' */



  /* RelationalOperator: '<S362>/Relational Operator2' incorporates:

   *  Constant: '<S362>/ACCEL_RATE_ABS_MAX_THRESHOLD_MS2_APV'

   */

  L4_MABX_B.f_accel_rate_greater_than_thres = (L4_MABX_B.MinMax8 >

    L4_MABX_P.ACCEL_RATE_ABS_MAX_THRESHOLD_MS);



  /* MinMax: '<S362>/MinMax7' */

  PositionFinalLimited = L4_MABX_B.AccelerationVector[0];

  for (i = 0; i < 32; i++) {

    Time56 = L4_MABX_B.AccelerationVector[i + 1];

    if (!((PositionFinalLimited < Time56) || rtIsNaN(Time56))) {

      PositionFinalLimited = Time56;

    }

  }



  L4_MABX_B.MinMax7 = PositionFinalLimited;



  /* End of MinMax: '<S362>/MinMax7' */



  /* RelationalOperator: '<S362>/Relational Operator3' incorporates:

   *  Constant: '<S362>/ACCEL_RATE_ABS_MIN_THRESHOLD_MS2_APV'

   */

  L4_MABX_B.f_decel_rate_greater_than_thres = (L4_MABX_B.MinMax7 <

    L4_MABX_P.ACCEL_RATE_ABS_MIN_THRESHOLD_MS);



  /* MinMax: '<S362>/MinMax10' */

  PositionFinalLimited = L4_MABX_B.JerkVector[0];

  for (i = 0; i < 32; i++) {

    Time56 = L4_MABX_B.JerkVector[i + 1];

    if (!((PositionFinalLimited > Time56) || rtIsNaN(Time56))) {

      PositionFinalLimited = Time56;

    }

  }



  L4_MABX_B.MinMax10 = PositionFinalLimited;



  /* End of MinMax: '<S362>/MinMax10' */



  /* RelationalOperator: '<S362>/Relational Operator4' incorporates:

   *  Constant: '<S362>/JERK_RATE_ABS_MAX_THRESHOLD_MS3_APV'

   */

  L4_MABX_B.f_jerk_rate_greater_than_thresh = (L4_MABX_B.MinMax10 >

    L4_MABX_P.JERK_RATE_ABS_MAX_THRESHOLD_MS3);



  /* MinMax: '<S362>/MinMax9' */

  PositionFinalLimited = L4_MABX_B.JerkVector[0];

  for (i = 0; i < 32; i++) {

    Time56 = L4_MABX_B.JerkVector[i + 1];

    if (!((PositionFinalLimited < Time56) || rtIsNaN(Time56))) {

      PositionFinalLimited = Time56;

    }

  }



  L4_MABX_B.MinMax9 = PositionFinalLimited;



  /* End of MinMax: '<S362>/MinMax9' */



  /* RelationalOperator: '<S362>/Relational Operator5' incorporates:

   *  Constant: '<S362>/JERK_RATE_ABS_MIN_THRESHOLD_MS3_APV'

   */

  L4_MABX_B.f_jerk_rate_greater_than_thre_n = (L4_MABX_B.MinMax9 <

    L4_MABX_P.JERK_RATE_ABS_MIN_THRESHOLD_MS3);



  /* Sum: '<S362>/Subtract2' */

  L4_MABX_B.Subtract2 = L4_MABX_B.Distance_to_achieve_speed_targe -

    L4_MABX_B.PositionVector[32];



  /* Abs: '<S362>/Abs2' */

  L4_MABX_B.Abs2 = fabs(L4_MABX_B.Subtract2);



  /* RelationalOperator: '<S362>/Relational Operator6' incorporates:

   *  Constant: '<S362>/MAX_DISTANCE_DELTA_THRESHOLD_M_APV'

   */

  L4_MABX_B.RelationalOperator6_i = (L4_MABX_B.Abs2 >

    L4_MABX_P.MAX_DISTANCE_DELTA_THRESHOLD_M_);



  /* Logic: '<S362>/Logical Operator3' */

  L4_MABX_B.f_distance_max_delta_greater_th = (L4_MABX_B.RelationalOperator6_i &&

    L4_MABX_B.LogicalOperator1_ph);



  /* Logic: '<S362>/Logical Operator4' */

  L4_MABX_B.F_Inhibit_sigmoid_vector_shapin =

    (L4_MABX_B.f_vspd_output_less_than_zero ||

     L4_MABX_B.f_vspd_min_delta_greater_than_t ||

     L4_MABX_B.f_vspd_max_delta_greater_than_t ||

     L4_MABX_B.f_accel_rate_greater_than_thres ||

     L4_MABX_B.f_decel_rate_greater_than_thres ||

     L4_MABX_B.f_jerk_rate_greater_than_thresh ||

     L4_MABX_B.f_jerk_rate_greater_than_thre_n ||

     L4_MABX_B.f_distance_max_delta_greater_th);



  /* Logic: '<S81>/Logical Operator' */

  L4_MABX_B.LogicalOperator_nd = !L4_MABX_B.F_Inhibit_sigmoid_vector_shapin;



  /* Logic: '<S81>/Logical Operator2' */

  L4_MABX_B.LogicalOperator2_ft = (L4_MABX_B.Compare_jr &&

    L4_MABX_B.LogicalOperator_nd);



  /* RelationalOperator: '<S363>/Relational Operator3' incorporates:

   *  Constant: '<S363>/CPV1'

   */

  L4_MABX_B.RelationalOperator3_k = (L4_MABX_B.Saturation5 <

    L4_MABX_P.CPV1_Value_i);



  /* RelationalOperator: '<S363>/Relational Operator1' incorporates:

   *  Constant: '<S350>/MIN_VSPD_SIGMOID_INITIAL_KPH_APV'

   */

  L4_MABX_B.RelationalOperator1_h = (L4_MABX_B.If_Then_Else_og.Switch <

    L4_MABX_P.MIN_VSPD_SIGMOID_INITIAL_KPH_AP);



  /* Logic: '<S363>/Logical Operator' */

  L4_MABX_B.LogicalOperator_da = (L4_MABX_B.RelationalOperator3_k ||

    L4_MABX_B.RelationalOperator1_h);



  /* RelationalOperator: '<S363>/Relational Operator2' incorporates:

   *  Constant: '<S350>/MIN_VSPD_SIGMOID_FINAL_KPH_APV'

   */

  L4_MABX_B.RelationalOperator2_g = (L4_MABX_B.VSPD_TARGET_KPH_APV_gu <

    L4_MABX_P.MIN_VSPD_SIGMOID_FINAL_KPH_APV_);



  /* Logic: '<S363>/Logical Operator2' */

  L4_MABX_B.F_set_max_distance_accumulated = (L4_MABX_B.LogicalOperator_da &&

    L4_MABX_B.RelationalOperator2_g);



  /* UnitDelay: '<S377>/FixPt Unit Delay2' */

  L4_MABX_B.FixPtUnitDelay2_o = L4_MABX_DW.FixPtUnitDelay2_DSTATE_f;



  /* Logic: '<S377>/FixPt Logical Operator' */

  L4_MABX_B.FixPtLogicalOperator = (uint8_T)(L4_MABX_B.LogicalOperator1_ja ||

    (L4_MABX_B.FixPtUnitDelay2_o != 0));



  /* UnitDelay: '<S377>/FixPt Unit Delay1' */

  L4_MABX_B.Xold_pg = L4_MABX_DW.FixPtUnitDelay1_DSTATE_l;



  /* Switch: '<S377>/Init' incorporates:

   *  Constant: '<S372>/CPV'

   */

  if (L4_MABX_B.FixPtLogicalOperator != 0) {

    L4_MABX_B.Init_h = L4_MABX_P.CPV_Value_h;

  } else {

    L4_MABX_B.Init_h = L4_MABX_B.Xold_pg;

  }



  /* End of Switch: '<S377>/Init' */



  /* Gain: '<S363>/Gain1' */

  L4_MABX_B.Gain1_c = L4_MABX_P.Gain1_Gain_k * L4_MABX_B.Saturation5;



  /* DigitalClock: '<S375>/Digital Clock' */

  L4_MABX_B.DigitalClock_f = L4_MABX_M->Timing.t[0];



  /* UnitDelay: '<S375>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_e = L4_MABX_DW.Unit_Delay_DSTATE_p;



  /* Sum: '<S375>/Subtract' */

  L4_MABX_B.Subtract_b = L4_MABX_B.DigitalClock_f - L4_MABX_B.Unit_Delay_e;



  /* Product: '<S372>/Product1' incorporates:

   *  Constant: '<S371>/CPV1'

   */

  L4_MABX_B.Product1_a = L4_MABX_P.CPV1_Value_e * L4_MABX_B.Gain1_c *

    L4_MABX_B.Subtract_b;



  /* Sum: '<S372>/Add' */

  L4_MABX_B.Add_h = L4_MABX_B.Init_h + L4_MABX_B.Product1_a;



  /* MinMax: '<S372>/MinMax' */

  DeltaTime = L4_MABX_B.Distance_to_achieve_speed_targe;

  PositionFinalLimited = L4_MABX_B.Add_h;

  if ((DeltaTime < PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax_a = PositionFinalLimited;



  /* End of MinMax: '<S372>/MinMax' */



  /* Outputs for Atomic SubSystem: '<S372>/If_Then_Else' */

  L4_MABX_If_Then_Else_g(L4_MABX_B.F_set_max_distance_accumulated,

    L4_MABX_B.Distance_to_achieve_speed_targe, L4_MABX_B.MinMax_a,

    &L4_MABX_B.If_Then_Else_gf);



  /* End of Outputs for SubSystem: '<S372>/If_Then_Else' */



  /* RelationalOperator: '<S363>/Relational Operator' */

  L4_MABX_B.RelationalOperator_lj = (L4_MABX_B.If_Then_Else_gf.Switch ==

    L4_MABX_B.Distance_to_achieve_speed_targe);



  /* S-Function (sfix_look1_dyn): '<S363>/Lookup Table Dynamic' */

  /* Dynamic Look-Up Table Block: '<S363>/Lookup Table Dynamic'

   * Input0  Data Type:  Floating Point real_T

   * Input1  Data Type:  Floating Point real_T

   * Input2  Data Type:  Floating Point real_T

   * Output0 Data Type:  Floating Point real_T

   * Lookup Method: Linear_Endpoint

   *

   */

  LookUp_real_T_real_T( &(L4_MABX_B.LookupTableDynamic),

                       &L4_MABX_B.Vehicle_speed_vector_kph[0],

                       L4_MABX_B.If_Then_Else_gf.Switch,

                       &L4_MABX_B.PositionVector[0], 32U);



  /* Outputs for Atomic SubSystem: '<S363>/If_Then_Else' */

  L4_MABX_If_Then_Else_g(L4_MABX_B.RelationalOperator_lj,

    L4_MABX_B.VSPD_TARGET_KPH_APV_gu, L4_MABX_B.LookupTableDynamic,

    &L4_MABX_B.If_Then_Else_jh);



  /* End of Outputs for SubSystem: '<S363>/If_Then_Else' */



  /* UnitDelay: '<S355>/Delay Input1' */

  L4_MABX_B.Uk1_k[0] = L4_MABX_DW.DelayInput1_DSTATE_f[0];

  L4_MABX_B.Uk1_k[1] = L4_MABX_DW.DelayInput1_DSTATE_f[1];



  /* RelationalOperator: '<S355>/FixPt Relational Operator' */

  L4_MABX_B.FixPtRelationalOperator_p[0] =

    (L4_MABX_B.Distance_to_achieve_speed_targe != L4_MABX_B.Uk1_k[0]);

  L4_MABX_B.FixPtRelationalOperator_p[1] = (L4_MABX_B.Vehicle_speed_target_o !=

    L4_MABX_B.Uk1_k[1]);



  /* Logic: '<S349>/Logical Operator' */

  L4_MABX_B.LogicalOperator_gb = (L4_MABX_B.FixPtRelationalOperator_p[0] ||

    L4_MABX_B.FixPtRelationalOperator_p[1]);



  /* UnitDelay: '<S357>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_l = L4_MABX_DW.Unit_Delay_DSTATE_l;



  /* Logic: '<S357>/Logical Operator1' */

  L4_MABX_B.LogicalOperator1_lp = (L4_MABX_B.LogicalOperator_gb ||

    L4_MABX_B.Unit_Delay_l);



  /* UnitDelay: '<S361>/FixPt Unit Delay2' */

  L4_MABX_B.FixPtUnitDelay2_nn = L4_MABX_DW.FixPtUnitDelay2_DSTATE_c;



  /* UnitDelay: '<S361>/FixPt Unit Delay1' */

  L4_MABX_B.Xold_o = L4_MABX_DW.FixPtUnitDelay1_DSTATE_ej;



  /* Switch: '<S361>/Init' */

  if (L4_MABX_B.FixPtUnitDelay2_nn != 0) {

    L4_MABX_B.Init_pn = L4_MABX_B.Vehicle_speed_target_o;

  } else {

    L4_MABX_B.Init_pn = L4_MABX_B.Xold_o;

  }



  /* End of Switch: '<S361>/Init' */



  /* UnitDelay: '<S356>/Unit_Delay' */

  L4_MABX_B.Vehicle_speed_target_c = L4_MABX_DW.Unit_Delay_1_DSTATE_j;

  L4_MABX_B.Vehicle_speed = L4_MABX_DW.Unit_Delay_2_DSTATE_e;

  L4_MABX_B.Distance_m = L4_MABX_DW.Unit_Delay_3_DSTATE_j;



  /* Outputs for Atomic SubSystem: '<S356>/If_Then_Else' */

  L4_MABX_If_Then_Else_m(L4_MABX_B.LogicalOperator_gb,

    L4_MABX_B.Vehicle_speed_target_o, L4_MABX_B.SFunction1_o1_gd,

    L4_MABX_B.Distance_to_achieve_speed_targe, L4_MABX_B.Vehicle_speed_target_c,

    L4_MABX_B.Vehicle_speed, L4_MABX_B.Distance_m, &L4_MABX_B.If_Then_Else_mm);



  /* End of Outputs for SubSystem: '<S356>/If_Then_Else' */



  /* Sum: '<S356>/Subtract' */

  L4_MABX_B.err = L4_MABX_B.If_Then_Else_mm.Vehicle_speed -

    L4_MABX_B.If_Then_Else_mm.Vehicle_speed_target;



  /* Abs: '<S356>/Abs2' */

  L4_MABX_B.err_abs = fabs(L4_MABX_B.err);



  /* Gain: '<S356>/Gain2' */

  L4_MABX_B.Gain2_k = L4_MABX_P.Gain2_Gain_l *

    L4_MABX_B.If_Then_Else_mm.Vehicle_speed;



  /* Saturate: '<S356>/Saturation4' */

  DeltaTime = L4_MABX_B.Gain2_k;

  Time56 = L4_MABX_P.Saturation4_LowerSat_e;

  AccelerationAverage = L4_MABX_P.Saturation4_UpperSat_a;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Saturation4 = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Saturation4 = Time56;

  } else {

    L4_MABX_B.Saturation4 = DeltaTime;

  }



  /* End of Saturate: '<S356>/Saturation4' */



  /* Product: '<S356>/Divide2' */

  L4_MABX_B.time_to_target_vspd_secs = L4_MABX_B.If_Then_Else_mm.Distance_m /

    L4_MABX_B.Saturation4;



  /* DigitalClock: '<S354>/Digital Clock' */

  L4_MABX_B.DigitalClock_p = L4_MABX_M->Timing.t[0];



  /* UnitDelay: '<S354>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_b = L4_MABX_DW.Unit_Delay_DSTATE_f;



  /* Sum: '<S354>/Subtract' */

  L4_MABX_B.Subtract_g = L4_MABX_B.DigitalClock_p - L4_MABX_B.Unit_Delay_b;



  /* MinMax: '<S356>/MinMax3' */

  DeltaTime = L4_MABX_B.time_to_target_vspd_secs;

  PositionFinalLimited = L4_MABX_B.Subtract_g;

  if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax3_n = PositionFinalLimited;



  /* End of MinMax: '<S356>/MinMax3' */



  /* Saturate: '<S356>/Saturation1' */

  DeltaTime = L4_MABX_B.MinMax3_n;

  Time56 = L4_MABX_P.Saturation1_LowerSat_o;

  AccelerationAverage = L4_MABX_P.Saturation1_UpperSat_j;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Saturation1_e = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Saturation1_e = Time56;

  } else {

    L4_MABX_B.Saturation1_e = DeltaTime;

  }



  /* End of Saturate: '<S356>/Saturation1' */



  /* Product: '<S356>/Divide' */

  L4_MABX_B.Divide_e = L4_MABX_B.err_abs / L4_MABX_B.Saturation1_e;



  /* Abs: '<S357>/Abs' */

  L4_MABX_B.Abs_ma = fabs(L4_MABX_B.Divide_e);



  /* Product: '<S357>/Product1' */

  L4_MABX_B.Product1_iv = L4_MABX_B.Abs_ma * L4_MABX_B.Subtract_g;



  /* Sum: '<S357>/Add1' */

  L4_MABX_B.Add1_bf = L4_MABX_B.Init_pn + L4_MABX_B.Product1_iv;



  /* MinMax: '<S357>/MinMax2' */

  DeltaTime = L4_MABX_B.Vehicle_speed_target_o;

  PositionFinalLimited = L4_MABX_B.Add1_bf;

  if ((DeltaTime < PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax2_c = PositionFinalLimited;



  /* End of MinMax: '<S357>/MinMax2' */



  /* Abs: '<S357>/Abs1' */

  L4_MABX_B.Abs1_f = fabs(L4_MABX_B.Divide_e);



  /* Product: '<S357>/Product2' */

  L4_MABX_B.Product2_m = L4_MABX_B.Subtract_g * L4_MABX_B.Abs1_f;



  /* Sum: '<S357>/Subtract1' */

  L4_MABX_B.Subtract1_h2 = L4_MABX_B.Init_pn - L4_MABX_B.Product2_m;



  /* MinMax: '<S357>/MinMax1' */

  DeltaTime = L4_MABX_B.MinMax2_c;

  PositionFinalLimited = L4_MABX_B.Subtract1_h2;

  if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax1_p = PositionFinalLimited;



  /* End of MinMax: '<S357>/MinMax1' */



  /* Outputs for Atomic SubSystem: '<S357>/If_Then_Else' */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator1_lp, L4_MABX_B.SFunction1_o1_gd,

                       L4_MABX_B.MinMax1_p, &L4_MABX_B.If_Then_Else_pz);



  /* End of Outputs for SubSystem: '<S357>/If_Then_Else' */



  /* Outputs for Atomic SubSystem: '<S81>/If_Then_Else' */

  L4_MABX_If_Then_Else_g(L4_MABX_B.LogicalOperator2_ft,

    L4_MABX_B.If_Then_Else_jh.Switch, L4_MABX_B.If_Then_Else_pz.Switch,

    &L4_MABX_B.If_Then_Else_ji);



  /* End of Outputs for SubSystem: '<S81>/If_Then_Else' */



  /* MinMax: '<S81>/MinMax' */

  DeltaTime = L4_MABX_B.If_Then_Else_m4.Switch;

  PositionFinalLimited = L4_MABX_B.If_Then_Else_bf.Switch;

  if ((DeltaTime < PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  Time56 = L4_MABX_B.Vehicle_speed_abs_max;

  if (!((PositionFinalLimited < Time56) || rtIsNaN(Time56))) {

    PositionFinalLimited = Time56;

  }



  Time56 = L4_MABX_B.If_Then_Else_ji.Switch;

  if (!((PositionFinalLimited < Time56) || rtIsNaN(Time56))) {

    PositionFinalLimited = Time56;

  }



  L4_MABX_B.MinMax_o = PositionFinalLimited;



  /* End of MinMax: '<S81>/MinMax' */



  /* Saturate: '<S81>/Saturation8' */

  DeltaTime = L4_MABX_B.MinMax_o;

  Time56 = L4_MABX_P.Saturation8_LowerSat;

  AccelerationAverage = L4_MABX_P.Saturation8_UpperSat;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Vehicle_speed_target_n = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Vehicle_speed_target_n = Time56;

  } else {

    L4_MABX_B.Vehicle_speed_target_n = DeltaTime;

  }



  /* End of Saturate: '<S81>/Saturation8' */



  /* Lookup_n-D: '<S200>/2D_Lookup_Table' */

  L4_MABX_B.uD_Lookup_Table_l = look2_binlcapw(0.0,

    L4_MABX_B.SPN1760_GrossCombinationVehicle, BRK_GOV_FF_DECEL_RATE_STEP_MPV,

    BRK_GOV_FF_MASS_STEP_MPV, BRK_GOV_FF_PRESS_KPA_DATA_MPV,

    L4_MABX_P.uD_Lookup_Table_maxIndex_e, 16U);



  /* Product: '<S106>/Divide' */

  L4_MABX_B.Divide_f = L4_MABX_B.uD_Lookup_Table_l /

    L4_MABX_B.Primary_brake_circuit_pressur_n;



  /* Gain: '<S106>/Gain1' */

  L4_MABX_B.Gain1_l = L4_MABX_P.Gain1_Gain_o * L4_MABX_B.Divide_f;



  /* Saturate: '<S106>/Saturation1' */

  DeltaTime = L4_MABX_B.Gain1_l;

  Time56 = L4_MABX_P.Saturation1_LowerSat_n;

  AccelerationAverage = L4_MABX_P.Saturation1_UpperSat_l;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Brake_appl_percent_to_achieve_d = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Brake_appl_percent_to_achieve_d = Time56;

  } else {

    L4_MABX_B.Brake_appl_percent_to_achieve_d = DeltaTime;

  }



  /* End of Saturate: '<S106>/Saturation1' */



  /* Saturate: '<S81>/Saturation2' incorporates:

   *  Constant: '<S81>/ACCEL_LIM_MS2_APV'

   */

  DeltaTime = L4_MABX_P.ACCEL_LIM_MS2_APV_Value;

  Time56 = L4_MABX_P.Saturation2_LowerSat_l;

  AccelerationAverage = L4_MABX_P.Saturation2_UpperSat_a;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.ACCEL_LIM_MS2_APV_b = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.ACCEL_LIM_MS2_APV_b = Time56;

  } else {

    L4_MABX_B.ACCEL_LIM_MS2_APV_b = DeltaTime;

  }



  /* End of Saturate: '<S81>/Saturation2' */



  /* Lookup_n-D: '<S201>/2D_Lookup_Table' */

  L4_MABX_B.uD_Lookup_Table_i = look2_binlcapw(L4_MABX_B.ACCEL_LIM_MS2_APV_b,

    L4_MABX_B.SPN1760_GrossCombinationVehicle, BRK_GOV_FF_DECEL_RATE_STEP_MPV,

    BRK_GOV_FF_MASS_STEP_MPV, BRK_GOV_FF_PRESS_KPA_DATA_MPV,

    L4_MABX_P.uD_Lookup_Table_maxIndex_n, 16U);



  /* Product: '<S106>/Divide1' */

  L4_MABX_B.Divide1_f = L4_MABX_B.uD_Lookup_Table_i /

    L4_MABX_B.Primary_brake_circuit_pressur_n;



  /* Gain: '<S106>/Gain2' */

  L4_MABX_B.Gain2_e = L4_MABX_P.Gain2_Gain_b * L4_MABX_B.Divide1_f;



  /* Saturate: '<S106>/Saturation2' */

  DeltaTime = L4_MABX_B.Gain2_e;

  Time56 = L4_MABX_P.Saturation2_LowerSat_o;

  AccelerationAverage = L4_MABX_P.Saturation2_UpperSat_b;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Brake_appl_percent_for_maximum_ = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Brake_appl_percent_for_maximum_ = Time56;

  } else {

    L4_MABX_B.Brake_appl_percent_for_maximum_ = DeltaTime;

  }



  /* End of Saturate: '<S106>/Saturation2' */



  /* DataTypeConversion: '<S77>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_l = L4_MABX_B.SPN1760_GrossCombinationVehicle;



  /* Outputs for Enabled SubSystem: '<S77>/Bendix_2C2_vehicle_speed_feedback_pressure_controller' incorporates:

   *  EnablePort: '<S103>/Enable'

   */

  if (L4_MABX_B.F_Brake_control_active) {

    if (!L4_MABX_DW.Bendix_2C2_vehicle_speed_feedba) {

      /* InitializeConditions for UnitDelay: '<S146>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_eu = L4_MABX_P.Unit_Delay_InitialCondition_f;



      /* InitializeConditions for UnitDelay: '<S153>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_n = L4_MABX_P.Unit_Delay_InitialCondition_jb;



      /* InitializeConditions for UnitDelay: '<S173>/Unit_Delay1' */

      L4_MABX_DW.Unit_Delay1_DSTATE_f = L4_MABX_P.Unit_Delay1_InitialCondition_p;



      /* InitializeConditions for UnitDelay: '<S174>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_g4 = L4_MABX_P.Unit_Delay_InitialCondition_lq;



      /* InitializeConditions for UnitDelay: '<S178>/FixPt Unit Delay2' */

      L4_MABX_DW.FixPtUnitDelay2_DSTATE_o =

        L4_MABX_P.FixPtUnitDelay2_InitialCondit_p;



      /* InitializeConditions for UnitDelay: '<S178>/FixPt Unit Delay1' */

      L4_MABX_DW.FixPtUnitDelay1_DSTATE_g2 =

        L4_MABX_P.FixPtUnitDelay1_InitialCondit_b;



      /* InitializeConditions for UnitDelay: '<S173>/Unit_Delay2' */

      L4_MABX_DW.Unit_Delay2_DSTATE_c = L4_MABX_P.Unit_Delay2_InitialCondition_b;



      /* InitializeConditions for UnitDelay: '<S145>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_h = L4_MABX_P.Unit_Delay_InitialCondition_h;

      L4_MABX_DW.Bendix_2C2_vehicle_speed_feedba = true;

    }



    /* Lookup_n-D: '<S147>/1D_Lookup_Table' */

    L4_MABX_B.uD_Lookup_Table_f = look1_binlcapw(L4_MABX_B.DataTypeConversion2_l,

      BRK_DEM_MASS_STEP_MPV, BRK_DEM_KP_DATA_MPV, 7U);



    /* Lookup_n-D: '<S148>/1D_Lookup_Table' */

    L4_MABX_B.uD_Lookup_Table_p = look1_binlcapw(L4_MABX_B.DataTypeConversion2_l,

      BRK_DEM_MASS_STEP_MPV, BRK_DEM_KI_DATA_MPV, 7U);



    /* Lookup_n-D: '<S149>/1D_Lookup_Table' */

    L4_MABX_B.uD_Lookup_Table_o5 = look1_binlcapw

      (L4_MABX_B.DataTypeConversion2_l, BRK_DEM_MASS_STEP_MPV,

       BRK_DEM_KD_DATA_MPV, 7U);



    /* Abs: '<S150>/Abs' */

    L4_MABX_B.Abs_k1 = fabs(L4_MABX_B.uD_Lookup_Table_p);



    /* Abs: '<S150>/Abs1' */

    L4_MABX_B.Abs1_eg = fabs(L4_MABX_B.uD_Lookup_Table_o5);



    /* DigitalClock: '<S146>/Digital Clock' */

    L4_MABX_B.DigitalClock_n = L4_MABX_M->Timing.t[0];



    /* UnitDelay: '<S146>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_ko = L4_MABX_DW.Unit_Delay_DSTATE_eu;



    /* Sum: '<S146>/Subtract' */

    L4_MABX_B.Subtract_ac = L4_MABX_B.DigitalClock_n - L4_MABX_B.Unit_Delay_ko;



    /* UnitDelay: '<S153>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_m1 = L4_MABX_DW.Unit_Delay_DSTATE_n;



    /* Logic: '<S153>/Logical Operator1' incorporates:

     *  Constant: '<S103>/CPV2'

     */

    L4_MABX_B.LogicalOperator1_pf = (L4_MABX_B.Unit_Delay_m1 ||

      L4_MABX_P.CPV2_Value_a);



    /* UnitDelay: '<S173>/Unit_Delay1' */

    L4_MABX_B.Unit_Delay1_jk = L4_MABX_DW.Unit_Delay1_DSTATE_f;



    /* Logic: '<S173>/Logical Operator' */

    L4_MABX_B.LogicalOperator_l = (L4_MABX_B.LogicalOperator1_pf ||

      L4_MABX_B.Unit_Delay1_jk);



    /* UnitDelay: '<S174>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_li = L4_MABX_DW.Unit_Delay_DSTATE_g4;



    /* Logic: '<S174>/Logical Operator1' */

    L4_MABX_B.LogicalOperator1_oy = (L4_MABX_B.LogicalOperator1_pf ||

      L4_MABX_B.Unit_Delay_li);



    /* UnitDelay: '<S178>/FixPt Unit Delay2' */

    L4_MABX_B.FixPtUnitDelay2_mf = L4_MABX_DW.FixPtUnitDelay2_DSTATE_o;



    /* UnitDelay: '<S178>/FixPt Unit Delay1' */

    L4_MABX_B.Xold_c = L4_MABX_DW.FixPtUnitDelay1_DSTATE_g2;



    /* Switch: '<S178>/Init' */

    if (L4_MABX_B.FixPtUnitDelay2_mf != 0) {

      L4_MABX_B.Init_cy = L4_MABX_B.Vehicle_speed_target_n;

    } else {

      L4_MABX_B.Init_cy = L4_MABX_B.Xold_c;

    }



    /* End of Switch: '<S178>/Init' */



    /* Abs: '<S174>/Abs' incorporates:

     *  Constant: '<S103>/BRK_DECEL_DEM_SLEW_INC_APV'

     */

    L4_MABX_B.Abs_o = fabs(L4_MABX_P.BRK_DECEL_DEM_SLEW_INC_APV_Valu);



    /* Product: '<S174>/Product1' */

    L4_MABX_B.Product1_hy = L4_MABX_B.Abs_o * L4_MABX_B.Subtract_ac;



    /* Sum: '<S174>/Add1' */

    L4_MABX_B.Add1_o = L4_MABX_B.Init_cy + L4_MABX_B.Product1_hy;



    /* MinMax: '<S174>/MinMax2' */

    DeltaTime = L4_MABX_B.Vehicle_speed_target_n;

    PositionFinalLimited = L4_MABX_B.Add1_o;

    if ((DeltaTime < PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

      PositionFinalLimited = DeltaTime;

    }



    L4_MABX_B.MinMax2_p = PositionFinalLimited;



    /* End of MinMax: '<S174>/MinMax2' */



    /* Abs: '<S174>/Abs1' incorporates:

     *  Constant: '<S103>/BRK_DECEL_DEM_SLEW_DEC_APV'

     */

    L4_MABX_B.Abs1_g = fabs(L4_MABX_P.BRK_DECEL_DEM_SLEW_DEC_APV_Valu);



    /* Product: '<S174>/Product2' */

    L4_MABX_B.Product2_fh = L4_MABX_B.Subtract_ac * L4_MABX_B.Abs1_g;



    /* Sum: '<S174>/Subtract1' */

    L4_MABX_B.Subtract1_fa = L4_MABX_B.Init_cy - L4_MABX_B.Product2_fh;



    /* MinMax: '<S174>/MinMax1' */

    DeltaTime = L4_MABX_B.MinMax2_p;

    PositionFinalLimited = L4_MABX_B.Subtract1_fa;

    if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

      PositionFinalLimited = DeltaTime;

    }



    L4_MABX_B.MinMax1_hl = PositionFinalLimited;



    /* End of MinMax: '<S174>/MinMax1' */



    /* Outputs for Atomic SubSystem: '<S174>/If_Then_Else' */

    L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator1_oy,

                         L4_MABX_B.DataTypeConversion5_o, L4_MABX_B.MinMax1_hl,

                         &L4_MABX_B.If_Then_Else_iy);



    /* End of Outputs for SubSystem: '<S174>/If_Then_Else' */



    /* Sum: '<S151>/Subtract' */

    L4_MABX_B.Subtract_jh = L4_MABX_B.If_Then_Else_iy.Switch -

      L4_MABX_B.DataTypeConversion5_o;



    /* MinMax: '<S173>/MinMax1' incorporates:

     *  Constant: '<S103>/BRK_DECEL_DEM_T_FILT_CTRL_ERROR_APV'

     */

    DeltaTime = L4_MABX_B.Subtract_ac;

    PositionFinalLimited = L4_MABX_P.BRK_DECEL_DEM_T_FILT_CTRL_ERROR;

    if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

      PositionFinalLimited = DeltaTime;

    }



    L4_MABX_B.MinMax1_jg = PositionFinalLimited;



    /* End of MinMax: '<S173>/MinMax1' */



    /* Saturate: '<S173>/Saturation' */

    DeltaTime = L4_MABX_B.MinMax1_jg;

    Time56 = L4_MABX_P.Saturation_LowerSat_g;

    AccelerationAverage = L4_MABX_P.Saturation_UpperSat_o;

    if (DeltaTime > AccelerationAverage) {

      L4_MABX_B.Saturation_m = AccelerationAverage;

    } else if (DeltaTime < Time56) {

      L4_MABX_B.Saturation_m = Time56;

    } else {

      L4_MABX_B.Saturation_m = DeltaTime;

    }



    /* End of Saturate: '<S173>/Saturation' */



    /* Product: '<S173>/Divide' */

    L4_MABX_B.Divide_af = L4_MABX_B.Subtract_ac / L4_MABX_B.Saturation_m;



    /* Product: '<S173>/Product2' */

    L4_MABX_B.Product2_ce = L4_MABX_B.Subtract_jh * L4_MABX_B.Divide_af;



    /* Sum: '<S173>/Subtract1' incorporates:

     *  Constant: '<S173>/Constant1'

     */

    L4_MABX_B.Subtract1_cr = L4_MABX_P.Constant1_Value_o - L4_MABX_B.Divide_af;



    /* UnitDelay: '<S173>/Unit_Delay2' */

    L4_MABX_B.Unit_Delay2_a = L4_MABX_DW.Unit_Delay2_DSTATE_c;



    /* Product: '<S173>/Product1' */

    L4_MABX_B.Product1_ch = L4_MABX_B.Subtract1_cr * L4_MABX_B.Unit_Delay2_a;



    /* Sum: '<S173>/Add1' */

    L4_MABX_B.Add1_hla = L4_MABX_B.Product2_ce + L4_MABX_B.Product1_ch;



    /* Outputs for Atomic SubSystem: '<S173>/If_Then_Else' */

    L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator_l, L4_MABX_B.Subtract_jh,

                         L4_MABX_B.Add1_hla, &L4_MABX_B.If_Then_Else_bc);



    /* End of Outputs for SubSystem: '<S173>/If_Then_Else' */



    /* RelationalOperator: '<S158>/Compare' incorporates:

     *  Constant: '<S158>/Constant'

     */

    L4_MABX_B.Compare_ni = (L4_MABX_B.Abs1_eg >

      L4_MABX_P.CompareToConstant1_const_m);



    /* Outputs for Enabled SubSystem: '<S150>/Calculate_D_term' */



    /* Constant: '<S103>/BRK_DECEL_DEM_T_FILT_D_APV' */

    L4_MABX_Calculate_D_term(L4_MABX_B.Compare_ni, L4_MABX_B.uD_Lookup_Table_o5,

      L4_MABX_B.Subtract_ac, L4_MABX_B.LogicalOperator1_pf,

      L4_MABX_B.If_Then_Else_bc.Switch,

      L4_MABX_P.BRK_DECEL_DEM_T_FILT_D_APV_Valu, &L4_MABX_B.Calculate_D_term_p,

      &L4_MABX_DW.Calculate_D_term_p, &L4_MABX_P.Calculate_D_term_p);



    /* End of Outputs for SubSystem: '<S150>/Calculate_D_term' */



    /* Product: '<S156>/Product' */

    L4_MABX_B.Product_f = L4_MABX_B.uD_Lookup_Table_f *

      L4_MABX_B.If_Then_Else_bc.Switch;



    /* UnitDelay: '<S145>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_fg = L4_MABX_DW.Unit_Delay_DSTATE_h;



    /* RelationalOperator: '<S157>/Compare' incorporates:

     *  Constant: '<S157>/Constant'

     */

    L4_MABX_B.Compare_dl = (L4_MABX_B.Abs_k1 >

      L4_MABX_P.CompareToConstant_const_c);



    /* Outputs for Enabled SubSystem: '<S150>/Calculate_I_term' */



    /* Constant: '<S103>/BRK_DECEL_DEM_AW_COND_INT_APV' incorporates:

     *  Constant: '<S103>/BRK_DECEL_DEM_AW_HYSTERESIS_APV'

     *  Constant: '<S103>/CPV1'

     */

    L4_MABX_Calculate_I_term(L4_MABX_B.Compare_dl, L4_MABX_B.Product_f,

      L4_MABX_B.uD_Lookup_Table_p, L4_MABX_B.Brake_appl_percent,

      L4_MABX_B.If_Then_Else_bc.Switch, L4_MABX_B.LogicalOperator1_pf,

      L4_MABX_B.Subtract_ac, L4_MABX_B.Brake_appl_percent_to_achieve_d,

      L4_MABX_P.BRK_DECEL_DEM_AW_COND_INT_APV_V,

      L4_MABX_P.BRK_DECEL_DEM_AW_HYSTERESIS_APV, L4_MABX_P.CPV1_Value_no,

      L4_MABX_B.Unit_Delay_fg, &L4_MABX_B.Calculate_I_term_e,

      &L4_MABX_DW.Calculate_I_term_e, &L4_MABX_P.Calculate_I_term_e);



    /* End of Outputs for SubSystem: '<S150>/Calculate_I_term' */



    /* RelationalOperator: '<S176>/min_relop' incorporates:

     *  Constant: '<S103>/BRK_DECEL_DEM_SLEW_INC_APV'

     *  Constant: '<S176>/min_val'

     */

    L4_MABX_B.min_relop_a5 = (L4_MABX_P.CheckStaticLowerBound_min_d <=

      L4_MABX_P.BRK_DECEL_DEM_SLEW_INC_APV_Valu);



    /* Assertion: '<S176>/Assertion' */

    utAssert(L4_MABX_B.min_relop_a5);



    /* Sum: '<S152>/Add' */

    L4_MABX_B.Add_mh = ((L4_MABX_B.Product_f +

                         L4_MABX_B.Calculate_I_term_e.If_Then_Else.Switch) +

                        L4_MABX_B.Calculate_D_term_p.Subtract) +

      L4_MABX_B.Brake_appl_percent_to_achieve_d;



    /* RelationalOperator: '<S179>/Relational Operator1' */

    L4_MABX_B.RelationalOperator1_k = (L4_MABX_B.Add_mh >=

      L4_MABX_B.Brake_appl_percent_for_maximum_);



    /* RelationalOperator: '<S179>/Relational Operator' incorporates:

     *  Constant: '<S103>/CPV'

     */

    L4_MABX_B.RelationalOperator_m1 = (L4_MABX_B.Add_mh <= L4_MABX_P.CPV_Value_i);



    /* Outputs for Atomic SubSystem: '<S179>/If_Then_Else1' */



    /* Constant: '<S103>/CPV' */

    L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator_m1, L4_MABX_P.CPV_Value_i,

                         L4_MABX_B.Add_mh, &L4_MABX_B.If_Then_Else1_gx);



    /* End of Outputs for SubSystem: '<S179>/If_Then_Else1' */



    /* Outputs for Atomic SubSystem: '<S179>/If_Then_Else' */

    L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator1_k,

                         L4_MABX_B.Brake_appl_percent_for_maximum_,

                         L4_MABX_B.If_Then_Else1_gx.Switch,

                         &L4_MABX_B.If_Then_Else_fo);



    /* End of Outputs for SubSystem: '<S179>/If_Then_Else' */

  } else {

    if (L4_MABX_DW.Bendix_2C2_vehicle_speed_feedba) {

      /* Disable for Enabled SubSystem: '<S150>/Calculate_D_term' */

      if (L4_MABX_DW.Calculate_D_term_p.Calculate_D_term_MODE) {

        L4_Calculate_D_term_Disable(&L4_MABX_B.Calculate_D_term_p,

          &L4_MABX_DW.Calculate_D_term_p, &L4_MABX_P.Calculate_D_term_p);

      }



      /* End of Disable for SubSystem: '<S150>/Calculate_D_term' */



      /* Disable for Enabled SubSystem: '<S150>/Calculate_I_term' */

      if (L4_MABX_DW.Calculate_I_term_e.Calculate_I_term_MODE) {

        L4_Calculate_I_term_Disable(&L4_MABX_B.Calculate_I_term_e,

          &L4_MABX_DW.Calculate_I_term_e, &L4_MABX_P.Calculate_I_term_e);

      }



      /* End of Disable for SubSystem: '<S150>/Calculate_I_term' */



      /* Disable for Outport: '<S103>/PID_output' */

      L4_MABX_B.If_Then_Else_fo.Switch = L4_MABX_P.PID_output_Y0_p;

      L4_MABX_DW.Bendix_2C2_vehicle_speed_feedba = false;

    }

  }



  /* End of Outputs for SubSystem: '<S77>/Bendix_2C2_vehicle_speed_feedback_pressure_controller' */



  /* RelationalOperator: '<S104>/Relational Operator2' incorporates:

   *  Constant: '<S104>/CPV2'

   */

  L4_MABX_B.F_Driver_braking = (L4_MABX_B.XPRControlMode ==

    L4_MABX_P.CPV2_Value_hm);



  /* Logic: '<S104>/Logical Operator2' */

  L4_MABX_B.F_Operator_brake_appl = (L4_MABX_B.If_Then_Else_la.Switch &&

    L4_MABX_B.F_Driver_braking);



  /* RelationalOperator: '<S104>/Relational Operator5' incorporates:

   *  Constant: '<S104>/BENDIX_2C2_BRAKE_APPL_THRESHOLD_KPA_APV'

   */

  L4_MABX_B.RelationalOperator5[0] = (L4_MABX_B.Bendix_2C2_Primary_brake_circui >

    L4_MABX_P.BENDIX_2C2_BRAKE_APPL_THRESHOLD);

  L4_MABX_B.RelationalOperator5[1] = (L4_MABX_B.Bendix_2C2_Secondary_brake_circ >

    L4_MABX_P.BENDIX_2C2_BRAKE_APPL_THRESHOLD);



  /* Logic: '<S104>/Logical Operator6' */

  L4_MABX_B.F_Bendix_2C2_service_brake_pres = (L4_MABX_B.RelationalOperator5[0] ||

    L4_MABX_B.RelationalOperator5[1]);



  /* RelationalOperator: '<S104>/Relational Operator' incorporates:

   *  Constant: '<S104>/CPV'

   */

  L4_MABX_B.F_Bendix_2C2_braking = (L4_MABX_B.XPRControlMode ==

    L4_MABX_P.CPV_Value_e);



  /* Logic: '<S104>/Logical Operator7' */

  L4_MABX_B.F_ADAS_brake_appl = (L4_MABX_B.If_Then_Else_la.Switch &&

    L4_MABX_B.F_Bendix_2C2_braking && L4_MABX_B.F_Bendix_2C2_service_brake_pres);



  /* RelationalOperator: '<S104>/Relational Operator1' incorporates:

   *  Constant: '<S104>/CPV1'

   */

  L4_MABX_B.F_ADAS_brake_error = (L4_MABX_B.XPRErrorState !=

    L4_MABX_P.CPV1_Value_i5);



  /* Lookup_n-D: '<S199>/2D_Lookup_Table' */

  L4_MABX_B.uD_Lookup_Table_le = look2_binlcapw

    (L4_MABX_B.brake_system_avg_appl_pressure_,

     L4_MABX_B.SPN1760_GrossCombinationVehicle, BRK_GOV_FF_PRESS_KPA_STEP_MPV,

     BRK_GOV_FF_MASS_STEP_MPV, BRK_GOV_FF_DECEL_RATE_DATA_MPV,

     L4_MABX_P.uD_Lookup_Table_maxIndex_m, 16U);



  /* Saturate: '<S106>/Saturation4' */

  DeltaTime = L4_MABX_B.uD_Lookup_Table_le;

  Time56 = L4_MABX_P.Saturation4_LowerSat_a;

  AccelerationAverage = L4_MABX_P.Saturation4_UpperSat_f;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Decel_rate_calculated_ms2 = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Decel_rate_calculated_ms2 = Time56;

  } else {

    L4_MABX_B.Decel_rate_calculated_ms2 = DeltaTime;

  }



  /* End of Saturate: '<S106>/Saturation4' */



  /* DataTypeConversion: '<S107>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_pp = L4_MABX_B.SFunction1_o1_au;



  /* DataTypeConversion: '<S107>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_k = L4_MABX_B.SFunction1_o2_hu;



  /* Sum: '<S107>/Add' */

  L4_MABX_B.Add_m = L4_MABX_B.DataTypeConversion_pp +

    L4_MABX_B.DataTypeConversion1_k;



  /* UnitDelay: '<S107>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_dy = L4_MABX_DW.Unit_Delay_DSTATE_eu4;



  /* UnitDelay: '<S203>/Unit_Delay1' */

  L4_MABX_B.Unit_Delay1_k = L4_MABX_DW.Unit_Delay1_DSTATE_di;



  /* Logic: '<S203>/Logical Operator' */

  L4_MABX_B.LogicalOperator_fc = (L4_MABX_B.Unit_Delay_dy ||

    L4_MABX_B.Unit_Delay1_k);



  /* Gain: '<S107>/Gain' */

  L4_MABX_B.Gain_j = L4_MABX_P.Gain_Gain_f * L4_MABX_B.Add_m;



  /* MinMax: '<S203>/MinMax1' incorporates:

   *  Constant: '<S107>/Constant10'

   *  Constant: '<S107>/VSPD_CAN_HRW_0B_FILT_T_APV'

   */

  DeltaTime = L4_MABX_P.Constant10_Value;

  PositionFinalLimited = L4_MABX_P.VSPD_CAN_HRW_0B_FILT_T_APV_Valu;

  if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax1_i = PositionFinalLimited;



  /* End of MinMax: '<S203>/MinMax1' */



  /* Saturate: '<S203>/Saturation' */

  DeltaTime = L4_MABX_B.MinMax1_i;

  Time56 = L4_MABX_P.Saturation_LowerSat_b;

  AccelerationAverage = L4_MABX_P.Saturation_UpperSat_l;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Saturation_nc = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Saturation_nc = Time56;

  } else {

    L4_MABX_B.Saturation_nc = DeltaTime;

  }



  /* End of Saturate: '<S203>/Saturation' */



  /* Product: '<S203>/Divide' incorporates:

   *  Constant: '<S107>/Constant10'

   */

  L4_MABX_B.Divide_a = L4_MABX_P.Constant10_Value / L4_MABX_B.Saturation_nc;



  /* Product: '<S203>/Product2' */

  L4_MABX_B.Product2_o = L4_MABX_B.Gain_j * L4_MABX_B.Divide_a;



  /* Sum: '<S203>/Subtract1' incorporates:

   *  Constant: '<S203>/Constant1'

   */

  L4_MABX_B.Subtract1_e = L4_MABX_P.Constant1_Value_od - L4_MABX_B.Divide_a;



  /* UnitDelay: '<S203>/Unit_Delay2' */

  L4_MABX_B.Unit_Delay2_g = L4_MABX_DW.Unit_Delay2_DSTATE_e;



  /* Product: '<S203>/Product1' */

  L4_MABX_B.Product1_o = L4_MABX_B.Subtract1_e * L4_MABX_B.Unit_Delay2_g;



  /* Sum: '<S203>/Add1' */

  L4_MABX_B.Add1_n1 = L4_MABX_B.Product2_o + L4_MABX_B.Product1_o;



  /* Outputs for Atomic SubSystem: '<S203>/If_Then_Else' */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator_fc, L4_MABX_B.Gain_j,

                       L4_MABX_B.Add1_n1, &L4_MABX_B.If_Then_Else_g);



  /* End of Outputs for SubSystem: '<S203>/If_Then_Else' */



  /* SampleTimeMath: '<S202>/TSamp'

   *

   * About '<S202>/TSamp':

   *  y = u * K where K = 1 / ( w * Ts )

   */

  L4_MABX_B.TSamp = L4_MABX_B.If_Then_Else_g.Switch * L4_MABX_P.TSamp_WtEt;



  /* UnitDelay: '<S202>/UD' */

  L4_MABX_B.Uk1_b = L4_MABX_DW.UD_DSTATE;



  /* Sum: '<S202>/Diff' */

  L4_MABX_B.Diff = L4_MABX_B.TSamp - L4_MABX_B.Uk1_b;



  /* MinMax: '<S77>/MinMax' */

  DeltaTime = L4_MABX_B.If_Then_Else_nj.Switch;

  PositionFinalLimited = L4_MABX_B.If_Then_Else_fo.Switch;

  if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.BrakingPID_Y_percent = PositionFinalLimited;



  /* End of MinMax: '<S77>/MinMax' */



  /* Gain: '<S77>/Gain' */

  L4_MABX_B.BrakingPID_Y_k = L4_MABX_P.Gain_Gain_no *

    L4_MABX_B.BrakingPID_Y_percent;



  /* DataTypeConversion: '<S79>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_de = L4_MABX_B.AutonomousEnabled_d;



  /* DataTypeConversion: '<S79>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_lf = (real32_T)L4_MABX_B.SFunction1_o1_gd;



  /* DataTypeConversion: '<S79>/Data Type Conversion1' */

  PositionFinalLimited = floor(L4_MABX_B.SFunction1_o8_fp);

  if (rtIsNaN(PositionFinalLimited) || rtIsInf(PositionFinalLimited)) {

    PositionFinalLimited = 0.0;

  } else {

    PositionFinalLimited = fmod(PositionFinalLimited, 256.0);

  }



  L4_MABX_B.DataTypeConversion1_f1 = (uint8_T)(PositionFinalLimited < 0.0 ?

    (int32_T)(uint8_T)-(int8_T)(uint8_T)-PositionFinalLimited : (int32_T)

    (uint8_T)PositionFinalLimited);



  /* End of DataTypeConversion: '<S79>/Data Type Conversion1' */



  /* Chart: '<S79>/Chart' incorporates:

   *  Constant: '<S79>/Constant'

   */

  /* Gateway: STATE_CONTROL_10ms/Chart */

  /* During: STATE_CONTROL_10ms/Chart */

  if (L4_MABX_DW.is_active_c19_SUB_L4_Task_10ms_ == 0U) {

    /* Entry: STATE_CONTROL_10ms/Chart */

    L4_MABX_DW.is_active_c19_SUB_L4_Task_10ms_ = 1U;



    /* Entry Internal: STATE_CONTROL_10ms/Chart */

    /* Transition: '<S207>:2' */

    L4_MABX_DW.is_c19_SUB_L4_Task_10ms_SUB_STA = L4_MABX_IN_Init;



    /* Entry 'Init': '<S207>:1' */

    L4_MABX_B.CtrlState = ENUM_AUTO_CTRL_STATE_T_INIT;

  } else {

    switch (L4_MABX_DW.is_c19_SUB_L4_Task_10ms_SUB_STA) {

     case L4_MABX_IN_Init:

      L4_MABX_B.CtrlState = ENUM_AUTO_CTRL_STATE_T_INIT;



      /* During 'Init': '<S207>:1' */

      if (!L4_MABX_P.Constant_Value_cp) {

        /* Transition: '<S207>:9' */

        L4_MABX_DW.is_c19_SUB_L4_Task_10ms_SUB_STA = L4_MABX_IN_OperatorDisabled;



        /* Entry 'OperatorDisabled': '<S207>:3' */

        L4_MABX_B.CtrlState = ENUM_AUTO_CTRL_STATE_T_OPERATOR_DISABLED;

      }

      break;



     case L4_MABX_IN_OperatorDisabled:

      L4_MABX_B.CtrlState = ENUM_AUTO_CTRL_STATE_T_OPERATOR_DISABLED;



      /* During 'OperatorDisabled': '<S207>:3' */

      if (L4_MABX_B.DataTypeConversion_de) {

        /* Transition: '<S207>:11' */

        L4_MABX_DW.is_c19_SUB_L4_Task_10ms_SUB_STA = L4_MABX_IN_OperatorEnabled;



        /* Entry 'OperatorEnabled': '<S207>:10' */

        L4_MABX_B.CtrlState = ENUM_AUTO_CTRL_STATE_T_AUTO_CTRL_ENABLED;



        /* Entry Internal 'OperatorEnabled': '<S207>:10' */

        /* Transition: '<S207>:16' */

        /* Entry 'AutoControlEnabled': '<S207>:13' */

        /* Entry Internal 'AutoControlEnabled': '<S207>:13' */

        /* Transition: '<S207>:15' */

        /* Entry 'init': '<S207>:14' */

        L4_MABX_B.VehCtrlState = ENUM_AUTO_CTRL_VEHICLE_STATE_T_INIT;

      }

      break;



     default:

      L4_MABX_B.CtrlState = ENUM_AUTO_CTRL_STATE_T_AUTO_CTRL_ENABLED;



      /* During 'OperatorEnabled': '<S207>:10' */

      if ((!L4_MABX_B.DataTypeConversion_de) || L4_MABX_P.Constant_Value_cp) {

        /* Transition: '<S207>:12' */

        /* Exit Internal 'OperatorEnabled': '<S207>:10' */

        /* Exit Internal 'AutoControlEnabled': '<S207>:13' */

        L4_MABX_DW.is_c19_SUB_L4_Task_10ms_SUB_STA = L4_MABX_IN_OperatorDisabled;



        /* Entry 'OperatorDisabled': '<S207>:3' */

        L4_MABX_B.CtrlState = ENUM_AUTO_CTRL_STATE_T_OPERATOR_DISABLED;

      } else {

        /* During 'AutoControlEnabled': '<S207>:13' */

        L4_MABX_B.VehCtrlState = ENUM_AUTO_CTRL_VEHICLE_STATE_T_INIT;



        /* During 'init': '<S207>:14' */

      }

      break;

    }

  }



  /* End of Chart: '<S79>/Chart' */



  /* Outputs for Enabled SubSystem: '<S79>/Engine_speed_target' incorporates:

   *  EnablePort: '<S210>/Enable'

   */

  if (L4_MABX_B.LogicalOperator_ke) {

    if (!L4_MABX_DW.Engine_speed_target_MODE) {

      L4_MABX_DW.Engine_speed_target_MODE = true;

    }



    /* Gain: '<S210>/KPH_TO_MPH' */

    L4_MABX_B.KPH_TO_MPH = L4_MABX_P.KPH_TO_MPH_Gain *

      L4_MABX_B.VSPD_TARGET_KPH_APV_g;



    /* MinMax: '<S210>/MinMax' incorporates:

     *  Constant: '<S210>/Constant2'

     *  Constant: '<S210>/TIRE_DIAM_INCHES_APV'

     */

    DeltaTime = L4_MABX_P.TIRE_DIAM_INCHES_APV_Value;

    PositionFinalLimited = L4_MABX_P.Constant2_Value_m;

    if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

      PositionFinalLimited = DeltaTime;

    }



    L4_MABX_B.MinMax_dl = PositionFinalLimited;



    /* End of MinMax: '<S210>/MinMax' */



    /* Product: '<S210>/Divide' incorporates:

     *  Constant: '<S210>/CONVERSION_CONSTANT_CPV'

     *  Constant: '<S210>/REAR_AXLE_RATIO_VALUE_APV'

     */

    L4_MABX_B.Divide_p = L4_MABX_B.KPH_TO_MPH *

      L4_MABX_B.SPN526_TransActualGearRatio *

      L4_MABX_P.REAR_AXLE_RATIO_VALUE_APV_Value *

      L4_MABX_P.CONVERSION_CONSTANT_CPV_Value / L4_MABX_B.MinMax_dl;



    /* MinMax: '<S210>/MinMax1' incorporates:

     *  Constant: '<S210>/Constant1'

     */

    DeltaTime = L4_MABX_B.Divide_p;

    PositionFinalLimited = L4_MABX_P.Constant1_Value_fx;

    if ((DeltaTime < PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

      PositionFinalLimited = DeltaTime;

    }



    L4_MABX_B.MinMax1_n = PositionFinalLimited;



    /* End of MinMax: '<S210>/MinMax1' */

  } else {

    if (L4_MABX_DW.Engine_speed_target_MODE) {

      /* Disable for Outport: '<S210>/Out1' */

      L4_MABX_B.MinMax1_n = L4_MABX_P.Out1_Y0;

      L4_MABX_DW.Engine_speed_target_MODE = false;

    }

  }



  /* End of Outputs for SubSystem: '<S79>/Engine_speed_target' */



  /* RelationalOperator: '<S211>/Relational Operator1' incorporates:

   *  Constant: '<S211>/CPV3'

   */

  L4_MABX_B.RelationalOperator1_cn = (L4_MABX_B.SFunction1_o1_gd <=

    L4_MABX_P.CPV3_Value_n);



  /* RelationalOperator: '<S211>/Relational Operator3' incorporates:

   *  Constant: '<S211>/CPV1'

   */

  L4_MABX_B.RelationalOperator3_g = (L4_MABX_B.SPN524_TransSelectedGear ==

    L4_MABX_P.CPV1_Value_n);



  /* RelationalOperator: '<S211>/Relational Operator2' incorporates:

   *  Constant: '<S211>/CPV2'

   */

  L4_MABX_B.RelationalOperator2_f = (L4_MABX_B.SPN523_TransCurrentGear ==

    L4_MABX_P.CPV2_Value_h);



  /* RelationalOperator: '<S211>/Relational Operator4' incorporates:

   *  Constant: '<S211>/CPV5'

   */

  L4_MABX_B.RelationalOperator4_o = (L4_MABX_B.SFunction1_o2_bl ==

    L4_MABX_P.CPV5_Value_g);



  /* Logic: '<S211>/Logical Operator' */

  L4_MABX_B.F_Ignition_sw_off_conditions_me = (L4_MABX_B.RelationalOperator1_cn &&

    L4_MABX_B.RelationalOperator3_g && L4_MABX_B.RelationalOperator2_f &&

    L4_MABX_B.RelationalOperator4_o);



  /* RelationalOperator: '<S211>/Relational Operator' incorporates:

   *  Constant: '<S211>/IGN_SW_VOLTAGE_THRESHOLD_APV'

   */

  L4_MABX_B.F_Ignition_sw_on = (L4_MABX_B.IgnitionKeySwitch_voltage >=

    L4_MABX_P.IGN_SW_VOLTAGE_THRESHOLD_APV_Va);



  /* SignalConversion: '<S218>/TmpSignal ConversionAt SFunction Inport3' incorporates:

   *  Chart: '<S211>/Relay_control_state_machine'

   *  Constant: '<S211>/IGN_RELAY_ON_DELAY_SECS_APV'

   *  Constant: '<S211>/INVERTER_RELAY_ON_DELAY_SECS_APV'

   *  Constant: '<S211>/MABX_RELAY_ON_DELAY_SECS_APV'

   *  Constant: '<S211>/SENSOR_RELAY_ON_DELAY_SECS_APV'

   */

  L4_MABX_B.TmpSignalConversionAtSFunctionI[0] =

    L4_MABX_P.IGN_RELAY_ON_DELAY_SECS_APV_Val;

  L4_MABX_B.TmpSignalConversionAtSFunctionI[1] =

    L4_MABX_P.INVERTER_RELAY_ON_DELAY_SECS_AP;

  L4_MABX_B.TmpSignalConversionAtSFunctionI[2] =

    L4_MABX_P.MABX_RELAY_ON_DELAY_SECS_APV_Va;

  L4_MABX_B.TmpSignalConversionAtSFunctionI[3] =

    L4_MABX_P.SENSOR_RELAY_ON_DELAY_SECS_APV_;



  /* SignalConversion: '<S218>/TmpSignal ConversionAt SFunction Inport4' incorporates:

   *  Chart: '<S211>/Relay_control_state_machine'

   *  Constant: '<S211>/IGN_RELAY_OFF_DELAY_SECS_APV'

   *  Constant: '<S211>/INVERTER_RELAY_OFF_DELAY_SECS_APV'

   *  Constant: '<S211>/MABX_RELAY_OFF_DELAY_SECS_APV'

   *  Constant: '<S211>/SENSOR_RELAY_OFF_DELAY_SECS_APV'

   */

  L4_MABX_B.TmpSignalConversionAtSFunctio_k[0] =

    L4_MABX_P.IGN_RELAY_OFF_DELAY_SECS_APV_Va;

  L4_MABX_B.TmpSignalConversionAtSFunctio_k[1] =

    L4_MABX_P.INVERTER_RELAY_OFF_DELAY_SECS_A;

  L4_MABX_B.TmpSignalConversionAtSFunctio_k[2] =

    L4_MABX_P.MABX_RELAY_OFF_DELAY_SECS_APV_V;

  L4_MABX_B.TmpSignalConversionAtSFunctio_k[3] =

    L4_MABX_P.SENSOR_RELAY_OFF_DELAY_SECS_APV;



  /* Chart: '<S211>/Relay_control_state_machine' */

  if (L4_MABX_DW.temporalCounter_i1 < MAX_uint32_T) {

    L4_MABX_DW.temporalCounter_i1++;

  }



  /* Gateway: STATE_CONTROL_10ms/Relay_control/Relay_control_state_machine */

  /* During: STATE_CONTROL_10ms/Relay_control/Relay_control_state_machine */

  if (L4_MABX_DW.is_active_c6_SUB_L4_Task_10ms_S == 0U) {

    /* Entry: STATE_CONTROL_10ms/Relay_control/Relay_control_state_machine */

    L4_MABX_DW.is_active_c6_SUB_L4_Task_10ms_S = 1U;



    /* Entry Internal: STATE_CONTROL_10ms/Relay_control/Relay_control_state_machine */

    /* Transition: '<S218>:13' */

    L4_MABX_DW.is_c6_SUB_L4_Task_10ms_SUB_STAT = L4_MABX_IN_INITIAL;

    L4_MABX_enter_atomic_INITIAL();

  } else {

    switch (L4_MABX_DW.is_c6_SUB_L4_Task_10ms_SUB_STAT) {

     case L4_MABX_IN_INITIAL:

      L4_MABX_B.F_Ignition_relay_command_i = false;

      L4_MABX_B.F_Inverter_relay_command_p = false;

      L4_MABX_B.F_MABX_relay_command_n = false;

      L4_MABX_B.F_Sensor_relay_command_k = false;



      /* During 'INITIAL': '<S218>:12' */

      if (L4_MABX_B.F_Ignition_sw_on) {

        /* Transition: '<S218>:17' */

        L4_MABX_DW.is_c6_SUB_L4_Task_10ms_SUB_STAT = L4_MABX_IN_POWER_UP_ROUTINE;



        /* Entry Internal 'POWER_UP_ROUTINE': '<S218>:16' */

        /* Transition: '<S218>:64' */

        L4_MABX_DW.is_POWER_UP_ROUTINE = L4_MABX_IN_WAIT;

        L4_MABX_DW.temporalCounter_i1 = 0U;

      }

      break;



     case L4_MABX_IN_POWER_DOWN_ROUTINE:

      /* During 'POWER_DOWN_ROUTINE': '<S218>:30' */

      switch (L4_MABX_DW.is_POWER_DOWN_ROUTINE) {

       case L4_MABX_IN_IGN_RELAY_UNLATCH:

        L4_MABX_B.F_Ignition_relay_command_i = false;



        /* During 'IGN_RELAY_UNLATCH': '<S218>:29' */

        if (L4_MABX_DW.temporalCounter_i1 >= (uint32_T)ceil

            (L4_MABX_DW.INVERTER_RELAY_OFF_DELAY_SECS_A * 100.0)) {

          /* Transition: '<S218>:23' */

          L4_MABX_DW.is_POWER_DOWN_ROUTINE = L4_MABX_IN_INV_RELAY_UNLATCH;

          L4_MABX_DW.temporalCounter_i1 = 0U;



          /* Entry 'INV_RELAY_UNLATCH': '<S218>:28' */

          L4_MABX_B.F_Inverter_relay_command_p = false;

        }

        break;



       case L4_MABX_IN_INV_RELAY_UNLATCH:

        L4_MABX_B.F_Inverter_relay_command_p = false;



        /* During 'INV_RELAY_UNLATCH': '<S218>:28' */

        if (L4_MABX_DW.temporalCounter_i1 >= (uint32_T)ceil

            (L4_MABX_DW.SENSOR_RELAY_OFF_DELAY_SECS_APV * 100.0)) {

          /* Transition: '<S218>:22' */

          L4_MABX_DW.is_POWER_DOWN_ROUTINE = L4_MABX_IN_SENSOR_RELAY_UNLATCH;

          L4_MABX_DW.temporalCounter_i1 = 0U;



          /* Entry 'SENSOR_RELAY_UNLATCH': '<S218>:25' */

          L4_MABX_B.F_Sensor_relay_command_k = false;

        }

        break;



       case L4_MABX_IN_MABX_RELAY_UNLATCH:

        L4_MABX_B.F_MABX_relay_command_n = false;



        /* During 'MABX_RELAY_UNLATCH': '<S218>:27' */

        /* Transition: '<S218>:45' */

        /* Transition: '<S218>:46' */

        /* Transition: '<S218>:47' */

        /* Transition: '<S218>:48' */

        L4_MABX_DW.is_POWER_DOWN_ROUTINE = L4_MABX_IN_NO_ACTIVE_CHILD;

        L4_MABX_DW.is_c6_SUB_L4_Task_10ms_SUB_STAT = L4_MABX_IN_INITIAL;

        L4_MABX_enter_atomic_INITIAL();

        break;



       case L4_MABX_IN_SENSOR_RELAY_UNLATCH:

        L4_MABX_B.F_Sensor_relay_command_k = false;



        /* During 'SENSOR_RELAY_UNLATCH': '<S218>:25' */

        if (L4_MABX_DW.temporalCounter_i1 >= (uint32_T)ceil

            (L4_MABX_DW.MABX_RELAY_OFF_DELAY_SECS_APV * 100.0)) {

          /* Transition: '<S218>:26' */

          L4_MABX_DW.is_POWER_DOWN_ROUTINE = L4_MABX_IN_MABX_RELAY_UNLATCH;



          /* Entry 'MABX_RELAY_UNLATCH': '<S218>:27' */

          L4_MABX_B.F_MABX_relay_command_n = false;

        }

        break;



       default:

        /* During 'WAIT': '<S218>:65' */

        if (L4_MABX_DW.temporalCounter_i1 >= (uint32_T)ceil

            (L4_MABX_DW.IGN_RELAY_OFF_DELAY_SECS_APV * 100.0)) {

          /* Transition: '<S218>:55' */

          L4_MABX_DW.is_POWER_DOWN_ROUTINE = L4_MABX_IN_IGN_RELAY_UNLATCH;

          L4_MABX_DW.temporalCounter_i1 = 0U;



          /* Entry 'IGN_RELAY_UNLATCH': '<S218>:29' */

          L4_MABX_B.F_Ignition_relay_command_i = false;

        }

        break;

      }

      break;



     default:

      /* During 'POWER_UP_ROUTINE': '<S218>:16' */

      zcEvent = ((!L4_MABX_B.F_Ignition_sw_on) &&

                 L4_MABX_B.F_Ignition_sw_off_conditions_me);

      if (zcEvent) {

        /* Transition: '<S218>:31' */

        /* Exit Internal 'POWER_UP_ROUTINE': '<S218>:16' */

        L4_MABX_DW.is_POWER_UP_ROUTINE = L4_MABX_IN_NO_ACTIVE_CHILD;

        L4_MABX_DW.is_c6_SUB_L4_Task_10ms_SUB_STAT =

          L4_MABX_IN_POWER_DOWN_ROUTINE;



        /* Entry Internal 'POWER_DOWN_ROUTINE': '<S218>:30' */

        /* Transition: '<S218>:66' */

        L4_MABX_DW.is_POWER_DOWN_ROUTINE = L4_MABX_IN_WAIT;

        L4_MABX_DW.temporalCounter_i1 = 0U;

      } else {

        switch (L4_MABX_DW.is_POWER_UP_ROUTINE) {

         case L4_MABX_IN_IGN_RELAY_LATCH:

          L4_MABX_B.F_Ignition_relay_command_i = true;



          /* During 'IGN_RELAY_LATCH': '<S218>:20' */

          break;



         case L4_MABX_IN_INV_RELAY_LATCH:

          L4_MABX_B.F_Inverter_relay_command_p = true;



          /* During 'INV_RELAY_LATCH': '<S218>:19' */

          if (L4_MABX_DW.temporalCounter_i1 >= (uint32_T)ceil

              (L4_MABX_DW.IGN_RELAY_ON_DELAY_SECS_APV * 100.0)) {

            /* Transition: '<S218>:21' */

            L4_MABX_DW.is_POWER_UP_ROUTINE = L4_MABX_IN_IGN_RELAY_LATCH;



            /* Entry 'IGN_RELAY_LATCH': '<S218>:20' */

            L4_MABX_B.F_Ignition_relay_command_i = true;

          }

          break;



         case L4_MABX_IN_MABX_RELAY_LATCH:

          L4_MABX_B.F_MABX_relay_command_n = true;



          /* During 'MABX_RELAY_LATCH': '<S218>:10' */

          if (L4_MABX_DW.temporalCounter_i1 >= (uint32_T)ceil

              (L4_MABX_DW.SENSOR_RELAY_ON_DELAY_SECS_APV * 100.0)) {

            /* Transition: '<S218>:15' */

            L4_MABX_DW.is_POWER_UP_ROUTINE = L4_MABX_IN_SENSOR_RELAY_LATCH;

            L4_MABX_DW.temporalCounter_i1 = 0U;



            /* Entry 'SENSOR_RELAY_LATCH': '<S218>:14' */

            L4_MABX_B.F_Sensor_relay_command_k = true;

          }

          break;



         case L4_MABX_IN_SENSOR_RELAY_LATCH:

          L4_MABX_B.F_Sensor_relay_command_k = true;



          /* During 'SENSOR_RELAY_LATCH': '<S218>:14' */

          if (L4_MABX_DW.temporalCounter_i1 >= (uint32_T)ceil

              (L4_MABX_DW.INVERTER_RELAY_ON_DELAY_SECS_AP * 100.0)) {

            /* Transition: '<S218>:18' */

            L4_MABX_DW.is_POWER_UP_ROUTINE = L4_MABX_IN_INV_RELAY_LATCH;

            L4_MABX_DW.temporalCounter_i1 = 0U;



            /* Entry 'INV_RELAY_LATCH': '<S218>:19' */

            L4_MABX_B.F_Inverter_relay_command_p = true;

          }

          break;



         default:

          /* During 'WAIT': '<S218>:63' */

          if (L4_MABX_DW.temporalCounter_i1 >= (uint32_T)ceil

              (L4_MABX_DW.MABX_RELAY_ON_DELAY_SECS_APV * 100.0)) {

            /* Transition: '<S218>:11' */

            L4_MABX_DW.is_POWER_UP_ROUTINE = L4_MABX_IN_MABX_RELAY_LATCH;

            L4_MABX_DW.temporalCounter_i1 = 0U;



            /* Entry 'MABX_RELAY_LATCH': '<S218>:10' */

            L4_MABX_B.F_MABX_relay_command_n = true;

          }

          break;

        }

      }

      break;

    }

  }



  /* Lookup_n-D: '<S79>/CurveBasedSpeedSetpoint' incorporates:

   *  Constant: '<S80>/zero'

   */

  L4_MABX_B.CurveBasedSpeedSetpoint = look1_binlcapw(L4_MABX_P.zero_Value,

    L4_MABX_P.CurveBasedSpeedSetpoint_bp01Dat,

    L4_MABX_P.CurveBasedSpeedSetpoint_tableDa, 4U);



  /* Lookup_n-D: '<S80>/1-D Lookup Table1' */

  L4_MABX_B.uDLookupTable1 = look1_binlxpw(SteerWheelAngle,

    L4_MABX_P.uDLookupTable1_bp01Data, L4_MABX_P.uDLookupTable1_tableData, 16U);



  /* Product: '<S285>/Divide' incorporates:

   *  Constant: '<S277>/Constant'

   *  Constant: '<S277>/Constant1'

   */

  L4_MABX_B.Divide_nn = (real32_T)(L4_MABX_P.Constant1_Value_i /

    L4_MABX_P.Constant_Value_e);



  /* DataTypeConversion: '<S80>/Data Type Conversion5' */

  PositionFinalLimited = floor(L4_MABX_B.SFunction1_o2_mr);

  if (rtIsNaN(PositionFinalLimited) || rtIsInf(PositionFinalLimited)) {

    PositionFinalLimited = 0.0;

  } else {

    PositionFinalLimited = fmod(PositionFinalLimited, 256.0);

  }



  L4_MABX_B.DataTypeConversion5_e3 = (uint8_T)(PositionFinalLimited < 0.0 ?

    (int32_T)(uint8_T)-(int8_T)(uint8_T)-PositionFinalLimited : (int32_T)

    (uint8_T)PositionFinalLimited);



  /* End of DataTypeConversion: '<S80>/Data Type Conversion5' */



  /* Chart: '<S283>/Chart' */

  /* Gateway: STEERCTRL_10ms/slew/Chart */

  /* During: STEERCTRL_10ms/slew/Chart */

  if (L4_MABX_DW.is_active_c12_SUB_L4_Task_10ms_ == 0U) {

    /* Entry: STEERCTRL_10ms/slew/Chart */

    L4_MABX_DW.is_active_c12_SUB_L4_Task_10ms_ = 1U;



    /* Entry Internal: STEERCTRL_10ms/slew/Chart */

    /* Transition: '<S339>:4' */

    L4_MABX_DW.is_c12_SUB_L4_Task_10ms_SUB_STE = L4_MABX_IN_init_a;



    /* Entry 'init': '<S339>:1' */

    L4_MABX_B.stateChange = 0U;

  } else {

    switch (L4_MABX_DW.is_c12_SUB_L4_Task_10ms_SUB_STE) {

     case L4_MABX_IN_OneLane:

      /* During 'OneLane': '<S339>:7' */

      /* Transition: '<S339>:20' */

      L4_MABX_DW.is_c12_SUB_L4_Task_10ms_SUB_STE = L4_MABX_IN_OneLane1;



      /* Entry 'OneLane1': '<S339>:18' */

      L4_MABX_B.stateChange = 0U;

      break;



     case L4_MABX_IN_OneLane1:

      L4_MABX_B.stateChange = 0U;



      /* During 'OneLane1': '<S339>:18' */

      zcEvent = ((L4_MABX_B.DataTypeConversion5_e3 < 3) ||

                 (L4_MABX_B.DataTypeConversion5_e3 > 18));

      if (zcEvent) {

        /* Transition: '<S339>:22' */

        L4_MABX_DW.is_c12_SUB_L4_Task_10ms_SUB_STE = L4_MABX_IN_init_a;



        /* Entry 'init': '<S339>:1' */

        L4_MABX_B.stateChange = 0U;

      }

      break;



     case L4_MABX_IN_TwoLanes:

      /* During 'TwoLanes': '<S339>:8' */

      /* Transition: '<S339>:21' */

      L4_MABX_DW.is_c12_SUB_L4_Task_10ms_SUB_STE = L4_MABX_IN_TwoLanes1;



      /* Entry 'TwoLanes1': '<S339>:19' */

      L4_MABX_B.stateChange = 0U;

      break;



     case L4_MABX_IN_TwoLanes1:

      L4_MABX_B.stateChange = 0U;



      /* During 'TwoLanes1': '<S339>:19' */

      if (L4_MABX_B.DataTypeConversion5_e3 < 18) {

        /* Transition: '<S339>:23' */

        L4_MABX_DW.is_c12_SUB_L4_Task_10ms_SUB_STE = L4_MABX_IN_init_a;



        /* Entry 'init': '<S339>:1' */

        L4_MABX_B.stateChange = 0U;

      }

      break;



     case L4_MABX_IN_ZeroLanes:

      /* During 'ZeroLanes': '<S339>:5' */

      /* Transition: '<S339>:16' */

      L4_MABX_DW.is_c12_SUB_L4_Task_10ms_SUB_STE = L4_MABX_IN_ZeroLanes1;



      /* Entry 'ZeroLanes1': '<S339>:15' */

      L4_MABX_B.stateChange = 0U;

      break;



     case L4_MABX_IN_ZeroLanes1:

      L4_MABX_B.stateChange = 0U;



      /* During 'ZeroLanes1': '<S339>:15' */

      if (L4_MABX_B.DataTypeConversion5_e3 > 3) {

        /* Transition: '<S339>:17' */

        L4_MABX_DW.is_c12_SUB_L4_Task_10ms_SUB_STE = L4_MABX_IN_init_a;



        /* Entry 'init': '<S339>:1' */

        L4_MABX_B.stateChange = 0U;

      }

      break;



     default:

      L4_MABX_B.stateChange = 0U;



      /* During 'init': '<S339>:1' */

      if (L4_MABX_B.DataTypeConversion5_e3 <= 3) {

        /* Transition: '<S339>:6' */

        L4_MABX_DW.is_c12_SUB_L4_Task_10ms_SUB_STE = L4_MABX_IN_ZeroLanes;



        /* Entry 'ZeroLanes': '<S339>:5' */

        L4_MABX_B.stateChange = 1U;

      } else if (L4_MABX_B.DataTypeConversion5_e3 > 18) {

        /* Transition: '<S339>:9' */

        L4_MABX_DW.is_c12_SUB_L4_Task_10ms_SUB_STE = L4_MABX_IN_TwoLanes;



        /* Entry 'TwoLanes': '<S339>:8' */

        L4_MABX_B.stateChange = 1U;

      } else {

        if (L4_MABX_B.DataTypeConversion5_e3 > 3) {

          /* Transition: '<S339>:10' */

          L4_MABX_DW.is_c12_SUB_L4_Task_10ms_SUB_STE = L4_MABX_IN_OneLane;



          /* Entry 'OneLane': '<S339>:7' */

          L4_MABX_B.stateChange = 1U;

        }

      }

      break;

    }

  }



  /* End of Chart: '<S283>/Chart' */



  /* DataTypeConversion: '<S283>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_l1 = (L4_MABX_B.stateChange != 0);



  /* UnitDelay: '<S333>/Unit_Delay1' */

  L4_MABX_B.Unit_Delay1_j = L4_MABX_DW.Unit_Delay1_DSTATE_db;



  /* Logic: '<S333>/Logical Operator' incorporates:

   *  Constant: '<S282>/zero'

   */

  L4_MABX_B.LogicalOperator_kh = (L4_MABX_P.zero_Value_g ||

    L4_MABX_B.Unit_Delay1_j);



  /* MinMax: '<S333>/MinMax1' incorporates:

   *  Constant: '<S282>/timeConstant'

   *  Constant: '<S282>/timeConstant1'

   */

  DeltaTime = L4_MABX_P.timeConstant1_Value;

  PositionFinalLimited = L4_MABX_P.timeConstant_Value;

  if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax1_pr = PositionFinalLimited;



  /* End of MinMax: '<S333>/MinMax1' */



  /* Saturate: '<S333>/Saturation' */

  DeltaTime = L4_MABX_B.MinMax1_pr;

  Time56 = L4_MABX_P.Saturation_LowerSat_p2;

  AccelerationAverage = L4_MABX_P.Saturation_UpperSat_o1;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Saturation_ns = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Saturation_ns = Time56;

  } else {

    L4_MABX_B.Saturation_ns = DeltaTime;

  }



  /* End of Saturate: '<S333>/Saturation' */



  /* Product: '<S333>/Divide' incorporates:

   *  Constant: '<S282>/timeConstant1'

   */

  L4_MABX_B.Divide_o = L4_MABX_P.timeConstant1_Value / L4_MABX_B.Saturation_ns;



  /* Product: '<S333>/Product2' */

  L4_MABX_B.Product2_b = L4_MABX_B.SFunction1_o3_ev * L4_MABX_B.Divide_o;



  /* Sum: '<S333>/Subtract1' incorporates:

   *  Constant: '<S333>/Constant1'

   */

  L4_MABX_B.Subtract1_ei = L4_MABX_P.Constant1_Value_n - L4_MABX_B.Divide_o;



  /* UnitDelay: '<S333>/Unit_Delay2' */

  L4_MABX_B.Unit_Delay2_k = L4_MABX_DW.Unit_Delay2_DSTATE_d;



  /* Product: '<S333>/Product1' */

  L4_MABX_B.Product1_n = L4_MABX_B.Subtract1_ei * L4_MABX_B.Unit_Delay2_k;



  /* Sum: '<S333>/Add1' */

  L4_MABX_B.Add1_k = L4_MABX_B.Product2_b + L4_MABX_B.Product1_n;



  /* Outputs for Atomic SubSystem: '<S333>/If_Then_Else' */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator_kh, L4_MABX_B.SFunction1_o3_ev,

                       L4_MABX_B.Add1_k, &L4_MABX_B.If_Then_Else_b3);



  /* End of Outputs for SubSystem: '<S333>/If_Then_Else' */



  /* Abs: '<S282>/Abs' */

  L4_MABX_B.Abs_ij = fabs(L4_MABX_B.SFunction1_o3_ev);



  /* Sum: '<S282>/Add' */

  L4_MABX_B.Add_p = L4_MABX_B.Abs_ij - L4_MABX_B.If_Then_Else_b3.Switch;



  /* RelationalOperator: '<S282>/highRateOfChange' incorporates:

   *  Constant: '<S282>/rateOfChangeThreshold'

   */

  L4_MABX_B.highRateOfChange = (L4_MABX_B.Add_p >

    L4_MABX_P.rateOfChangeThreshold_Value);



  /* RelationalOperator: '<S282>/closeToEdge' incorporates:

   *  Constant: '<S282>/closeToLaneEdgeThreshold'

   */

  L4_MABX_B.closeToEdge = (L4_MABX_B.Abs_ij >

    L4_MABX_P.closeToLaneEdgeThreshold_Value);



  /* Logic: '<S282>/JumpNearEdge' */

  L4_MABX_B.JumpNearEdge = (L4_MABX_B.highRateOfChange && L4_MABX_B.closeToEdge);



  /* UnitDelay: '<S332>/Delay Input1' */

  L4_MABX_B.Uk1_k2 = L4_MABX_DW.DelayInput1_DSTATE_f0;



  /* RelationalOperator: '<S332>/FixPt Relational Operator' */

  L4_MABX_B.FixPtRelationalOperator_iv = (L4_MABX_B.JumpNearEdge !=

    L4_MABX_B.Uk1_k2);



  /* DataTypeConversion: '<S282>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_dz = L4_MABX_B.FixPtRelationalOperator_iv;



  /* UnitDelay: '<S334>/Unit_Delay1' */

  L4_MABX_B.Unit_Delay1_f = L4_MABX_DW.Unit_Delay1_DSTATE_a;



  /* Logic: '<S334>/Logical Operator' */

  L4_MABX_B.LogicalOperator_a = (L4_MABX_B.DataTypeConversion_dz ||

    L4_MABX_B.Unit_Delay1_f);



  /* Switch: '<S282>/Switch' incorporates:

   *  Constant: '<S282>/correction'

   *  Constant: '<S282>/zero1'

   */

  if (L4_MABX_B.JumpNearEdge) {

    L4_MABX_B.Switch_g = L4_MABX_P.correction_Value;

  } else {

    L4_MABX_B.Switch_g = L4_MABX_P.zero1_Value;

  }



  /* End of Switch: '<S282>/Switch' */



  /* MinMax: '<S334>/MinMax1' incorporates:

   *  Constant: '<S282>/timeConstant2'

   *  Constant: '<S282>/timeConstant3'

   */

  DeltaTime = L4_MABX_P.timeConstant3_Value;

  PositionFinalLimited = L4_MABX_P.timeConstant2_Value;

  if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax1_au = PositionFinalLimited;



  /* End of MinMax: '<S334>/MinMax1' */



  /* Saturate: '<S334>/Saturation' */

  DeltaTime = L4_MABX_B.MinMax1_au;

  Time56 = L4_MABX_P.Saturation_LowerSat_ph;

  AccelerationAverage = L4_MABX_P.Saturation_UpperSat_d;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Saturation_e = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Saturation_e = Time56;

  } else {

    L4_MABX_B.Saturation_e = DeltaTime;

  }



  /* End of Saturate: '<S334>/Saturation' */



  /* Product: '<S334>/Divide' incorporates:

   *  Constant: '<S282>/timeConstant3'

   */

  L4_MABX_B.Divide_d = L4_MABX_P.timeConstant3_Value / L4_MABX_B.Saturation_e;



  /* Product: '<S334>/Product2' */

  L4_MABX_B.Product2_f = L4_MABX_B.Switch_g * L4_MABX_B.Divide_d;



  /* Sum: '<S334>/Subtract1' incorporates:

   *  Constant: '<S334>/Constant1'

   */

  L4_MABX_B.Subtract1_b = L4_MABX_P.Constant1_Value_j - L4_MABX_B.Divide_d;



  /* UnitDelay: '<S334>/Unit_Delay2' */

  L4_MABX_B.Unit_Delay2_l = L4_MABX_DW.Unit_Delay2_DSTATE_i;



  /* Product: '<S334>/Product1' */

  L4_MABX_B.Product1_c = L4_MABX_B.Subtract1_b * L4_MABX_B.Unit_Delay2_l;



  /* Sum: '<S334>/Add1' */

  L4_MABX_B.Add1_pt = L4_MABX_B.Product2_f + L4_MABX_B.Product1_c;



  /* Outputs for Atomic SubSystem: '<S334>/If_Then_Else' */



  /* Constant: '<S282>/zero2' */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator_a, L4_MABX_P.zero2_Value,

                       L4_MABX_B.Add1_pt, &L4_MABX_B.If_Then_Else_mk);



  /* End of Outputs for SubSystem: '<S334>/If_Then_Else' */



  /* Signum: '<S282>/Sign' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o3_ev;

  if (PositionFinalLimited < 0.0) {

    L4_MABX_B.Sign = -1.0;

  } else if (PositionFinalLimited > 0.0) {

    L4_MABX_B.Sign = 1.0;

  } else if (PositionFinalLimited == 0.0) {

    L4_MABX_B.Sign = 0.0;

  } else {

    L4_MABX_B.Sign = (rtNaN);

  }



  /* End of Signum: '<S282>/Sign' */



  /* Product: '<S282>/Product' */

  L4_MABX_B.Product_cf = L4_MABX_B.If_Then_Else_mk.Switch * L4_MABX_B.Sign;



  /* UnitDelay: '<S335>/Unit_Delay1' */

  L4_MABX_B.Unit_Delay1_de = L4_MABX_DW.Unit_Delay1_DSTATE_p3;



  /* Logic: '<S335>/Logical Operator' incorporates:

   *  Constant: '<S282>/zero3'

   */

  L4_MABX_B.LogicalOperator_nz = (L4_MABX_P.zero3_Value ||

    L4_MABX_B.Unit_Delay1_de);



  /* MinMax: '<S335>/MinMax1' incorporates:

   *  Constant: '<S282>/timeConstant4'

   *  Constant: '<S282>/timeConstant5'

   */

  DeltaTime = L4_MABX_P.timeConstant5_Value;

  PositionFinalLimited = L4_MABX_P.timeConstant4_Value;

  if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax1_e0 = PositionFinalLimited;



  /* End of MinMax: '<S335>/MinMax1' */



  /* Saturate: '<S335>/Saturation' */

  DeltaTime = L4_MABX_B.MinMax1_e0;

  Time56 = L4_MABX_P.Saturation_LowerSat_k;

  AccelerationAverage = L4_MABX_P.Saturation_UpperSat_ok;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Saturation_o = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Saturation_o = Time56;

  } else {

    L4_MABX_B.Saturation_o = DeltaTime;

  }



  /* End of Saturate: '<S335>/Saturation' */



  /* Product: '<S335>/Divide' incorporates:

   *  Constant: '<S282>/timeConstant5'

   */

  L4_MABX_B.Divide_j = L4_MABX_P.timeConstant5_Value / L4_MABX_B.Saturation_o;



  /* Product: '<S335>/Product2' */

  L4_MABX_B.Product2_nk = L4_MABX_B.SFunction1_o3_ev * L4_MABX_B.Divide_j;



  /* Sum: '<S335>/Subtract1' incorporates:

   *  Constant: '<S335>/Constant1'

   */

  L4_MABX_B.Subtract1_eh = L4_MABX_P.Constant1_Value_oi - L4_MABX_B.Divide_j;



  /* UnitDelay: '<S335>/Unit_Delay2' */

  L4_MABX_B.Unit_Delay2_c = L4_MABX_DW.Unit_Delay2_DSTATE_p;



  /* Product: '<S335>/Product1' */

  L4_MABX_B.Product1_cc = L4_MABX_B.Subtract1_eh * L4_MABX_B.Unit_Delay2_c;



  /* Sum: '<S335>/Add1' */

  L4_MABX_B.Add1_f = L4_MABX_B.Product2_nk + L4_MABX_B.Product1_cc;



  /* Outputs for Atomic SubSystem: '<S335>/If_Then_Else' */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator_nz, L4_MABX_B.SFunction1_o3_ev,

                       L4_MABX_B.Add1_f, &L4_MABX_B.If_Then_Else_lh);



  /* End of Outputs for SubSystem: '<S335>/If_Then_Else' */



  /* Switch: '<S282>/Switch1' */

  if (L4_MABX_B.JumpNearEdge) {

    L4_MABX_B.Switch1_f = L4_MABX_B.If_Then_Else_lh.Switch;

  } else {

    L4_MABX_B.Switch1_f = L4_MABX_B.SFunction1_o3_ev;

  }



  /* End of Switch: '<S282>/Switch1' */



  /* Sum: '<S282>/corrected Error' */

  L4_MABX_B.correctedError = L4_MABX_B.Product_cf + L4_MABX_B.Switch1_f;



  /* RelationalOperator: '<S283>/Relational Operator' incorporates:

   *  Constant: '<S283>/Constant'

   */

  L4_MABX_B.RelationalOperator_l5 = (L4_MABX_B.DataTypeConversion5_e3 >=

    L4_MABX_P.Constant_Value_mg);



  /* Switch: '<S283>/Switch' incorporates:

   *  Constant: '<S283>/Constant1'

   */

  if (L4_MABX_B.RelationalOperator_l5) {

    L4_MABX_B.Switch_hq = L4_MABX_B.correctedError;

  } else {

    L4_MABX_B.Switch_hq = L4_MABX_P.Constant1_Value_l;

  }



  /* End of Switch: '<S283>/Switch' */



  /* Outputs for Enabled SubSystem: '<S283>/Slew_at_event' incorporates:

   *  EnablePort: '<S340>/Enable'

   */

  /* Constant: '<S283>/enable' */

  if (L4_MABX_P.enable_Value > 0.0) {

    if (!L4_MABX_DW.Slew_at_event_MODE_d) {

      /* InitializeConditions for UnitDelay: '<S342>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_bd = L4_MABX_P.Unit_Delay_InitialCondition_ls;



      /* InitializeConditions for UnitDelay: '<S343>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_jt = L4_MABX_P.Unit_Delay_InitialCondition_i0;



      /* InitializeConditions for UnitDelay: '<S346>/FixPt Unit Delay2' */

      L4_MABX_DW.FixPtUnitDelay2_DSTATE_j =

        L4_MABX_P.FixPtUnitDelay2_InitialCondit_c;



      /* InitializeConditions for UnitDelay: '<S346>/FixPt Unit Delay1' */

      L4_MABX_DW.FixPtUnitDelay1_DSTATE_ov =

        L4_MABX_P.FixPtUnitDelay1_InitialCondit_f;



      /* InitializeConditions for UnitDelay: '<S341>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_ll = L4_MABX_P.Unit_Delay_InitialCondition_ld;

      L4_MABX_DW.Slew_at_event_MODE_d = true;

    }



    /* UnitDelay: '<S342>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_o3 = L4_MABX_DW.Unit_Delay_DSTATE_bd;



    /* Logic: '<S342>/Logical Operator1' */

    L4_MABX_B.LogicalOperator1_gw = !L4_MABX_B.Unit_Delay_o3;



    /* Logic: '<S342>/Logical Operator' */

    L4_MABX_B.LogicalOperator_d2 = (L4_MABX_B.DataTypeConversion_l1 &&

      L4_MABX_B.LogicalOperator1_gw);



    /* UnitDelay: '<S343>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_hj = L4_MABX_DW.Unit_Delay_DSTATE_jt;



    /* Logic: '<S343>/Logical Operator1' */

    L4_MABX_B.LogicalOperator1_h = (L4_MABX_B.LogicalOperator_d2 ||

      L4_MABX_B.Unit_Delay_hj);



    /* UnitDelay: '<S346>/FixPt Unit Delay2' */

    L4_MABX_B.FixPtUnitDelay2_h5 = L4_MABX_DW.FixPtUnitDelay2_DSTATE_j;



    /* UnitDelay: '<S346>/FixPt Unit Delay1' */

    L4_MABX_B.Xold_g = L4_MABX_DW.FixPtUnitDelay1_DSTATE_ov;



    /* Switch: '<S346>/Init' */

    if (L4_MABX_B.FixPtUnitDelay2_h5 != 0) {

      L4_MABX_B.Init_jw = L4_MABX_B.Switch_hq;

    } else {

      L4_MABX_B.Init_jw = L4_MABX_B.Xold_g;

    }



    /* End of Switch: '<S346>/Init' */



    /* Abs: '<S343>/Abs' incorporates:

     *  Constant: '<S283>/Constant3'

     */

    L4_MABX_B.Abs_a = fabs(L4_MABX_P.Constant3_Value_j);



    /* Product: '<S343>/Product1' incorporates:

     *  Constant: '<S283>/Constant2'

     */

    L4_MABX_B.Product1_i3 = L4_MABX_B.Abs_a * L4_MABX_P.Constant2_Value_p;



    /* Sum: '<S343>/Add1' */

    L4_MABX_B.Add1_b0 = L4_MABX_B.Init_jw + L4_MABX_B.Product1_i3;



    /* MinMax: '<S343>/MinMax2' */

    DeltaTime = L4_MABX_B.Switch_hq;

    PositionFinalLimited = L4_MABX_B.Add1_b0;

    if ((DeltaTime < PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

      PositionFinalLimited = DeltaTime;

    }



    L4_MABX_B.MinMax2_l = PositionFinalLimited;



    /* End of MinMax: '<S343>/MinMax2' */



    /* Abs: '<S343>/Abs1' incorporates:

     *  Constant: '<S283>/Constant4'

     */

    L4_MABX_B.Abs1_e = fabs(L4_MABX_P.Constant4_Value_bq);



    /* Product: '<S343>/Product2' incorporates:

     *  Constant: '<S283>/Constant2'

     */

    L4_MABX_B.Product2_k = L4_MABX_P.Constant2_Value_p * L4_MABX_B.Abs1_e;



    /* Sum: '<S343>/Subtract1' */

    L4_MABX_B.Subtract1_g = L4_MABX_B.Init_jw - L4_MABX_B.Product2_k;



    /* MinMax: '<S343>/MinMax1' */

    DeltaTime = L4_MABX_B.MinMax2_l;

    PositionFinalLimited = L4_MABX_B.Subtract1_g;

    if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

      PositionFinalLimited = DeltaTime;

    }



    L4_MABX_B.MinMax1_k = PositionFinalLimited;



    /* End of MinMax: '<S343>/MinMax1' */



    /* Outputs for Atomic SubSystem: '<S343>/If_Then_Else' */

    L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator1_h, L4_MABX_B.Switch_hq,

                         L4_MABX_B.MinMax1_k, &L4_MABX_B.If_Then_Else_n3);



    /* End of Outputs for SubSystem: '<S343>/If_Then_Else' */



    /* Sum: '<S340>/Subtract' */

    L4_MABX_B.Subtract_ij = L4_MABX_B.Switch_hq -

      L4_MABX_B.If_Then_Else_n3.Switch;



    /* Abs: '<S340>/Abs' */

    L4_MABX_B.Abs_eu = fabs(L4_MABX_B.Subtract_ij);



    /* RelationalOperator: '<S340>/Relational Operator1' incorporates:

     *  Constant: '<S340>/Constant1'

     */

    L4_MABX_B.RelationalOperator1_e = (L4_MABX_B.Abs_eu <=

      L4_MABX_P.Constant1_Value_ah);



    /* Logic: '<S341>/Logical Operator3' */

    L4_MABX_B.LogicalOperator3_a = !L4_MABX_B.RelationalOperator1_e;



    /* UnitDelay: '<S341>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_ig = L4_MABX_DW.Unit_Delay_DSTATE_ll;



    /* Logic: '<S341>/Logical Operator1' */

    L4_MABX_B.LogicalOperator1_jo = (L4_MABX_B.DataTypeConversion_l1 ||

      L4_MABX_B.Unit_Delay_ig);



    /* Logic: '<S341>/Logical Operator' */

    L4_MABX_B.LogicalOperator_dm = (L4_MABX_B.LogicalOperator3_a &&

      L4_MABX_B.LogicalOperator1_jo);



    /* Logic: '<S341>/Logical Operator2' */

    L4_MABX_B.LogicalOperator2_jq = !L4_MABX_B.LogicalOperator_dm;



    /* RelationalOperator: '<S344>/min_relop' incorporates:

     *  Constant: '<S283>/Constant3'

     *  Constant: '<S344>/min_val'

     */

    L4_MABX_B.min_relop_d = (L4_MABX_P.CheckStaticLowerBound_min_n <=

      L4_MABX_P.Constant3_Value_j);



    /* Assertion: '<S344>/Assertion' */

    utAssert(L4_MABX_B.min_relop_d);

  } else {

    if (L4_MABX_DW.Slew_at_event_MODE_d) {

      /* Disable for Outport: '<S340>/F_Out_slewing' */

      L4_MABX_B.LogicalOperator_dm = L4_MABX_P.F_Out_slewing_Y0;



      /* Disable for Outport: '<S340>/Out' */

      L4_MABX_B.If_Then_Else_n3.Switch = L4_MABX_P.Out_Y0;

      L4_MABX_DW.Slew_at_event_MODE_d = false;

    }

  }



  /* End of Constant: '<S283>/enable' */

  /* End of Outputs for SubSystem: '<S283>/Slew_at_event' */



  /* Switch: '<S283>/Switch1' incorporates:

   *  Constant: '<S283>/enableSlew'

   */

  if (L4_MABX_P.enableSlew_Value != 0.0) {

    L4_MABX_B.Switch1_j = L4_MABX_B.If_Then_Else_n3.Switch;

  } else {

    L4_MABX_B.Switch1_j = L4_MABX_B.Switch_hq;

  }



  /* End of Switch: '<S283>/Switch1' */



  /* Gain: '<S80>/sign' */

  L4_MABX_B.SteerCtrlErrRaw = L4_MABX_P.sign_Gain * L4_MABX_B.Switch1_j;



  /* DataTypeConversion: '<S80>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_ev = L4_MABX_B.SteerCtrlErrRaw;



  /* UnitDelay: '<S285>/Unit Delay' */

  L4_MABX_B.UnitDelay_fm = L4_MABX_DW.UnitDelay_DSTATE_d;



  /* Switch: '<S289>/Switch1' incorporates:

   *  Constant: '<S285>/E'

   *  Constant: '<S285>/R'

   *  Switch: '<S287>/Switch1'

   */

  if (L4_MABX_P.R_Value) {

    /* DataTypeConversion: '<S285>/Data Type Conversion1' incorporates:

     *  Constant: '<S285>/IV'

     */

    L4_MABX_B.DataTypeConversion1_b1 = (real32_T)L4_MABX_P.IV_Value;

    L4_MABX_B.Switch1_fi = L4_MABX_B.DataTypeConversion1_b1;

  } else {

    if (L4_MABX_P.E_Value_j) {

      /* DataTypeConversion: '<S285>/Data Type Conversion' incorporates:

       *  Switch: '<S287>/Switch1'

       */

      L4_MABX_B.DataTypeConversion_ps = (real32_T)

        L4_MABX_B.DataTypeConversion1_ev;



      /* Sum: '<S285>/Add3' incorporates:

       *  Switch: '<S287>/Switch1'

       */

      L4_MABX_B.Add3_j = L4_MABX_B.DataTypeConversion_ps -

        L4_MABX_B.UnitDelay_fm;



      /* Product: '<S285>/Product1' incorporates:

       *  Switch: '<S287>/Switch1'

       */

      L4_MABX_B.Product1_n2 = L4_MABX_B.Divide_nn * L4_MABX_B.Add3_j;



      /* Sum: '<S285>/Add' incorporates:

       *  Switch: '<S287>/Switch1'

       */

      L4_MABX_B.Add_f = L4_MABX_B.Product1_n2 + L4_MABX_B.UnitDelay_fm;



      /* Switch: '<S287>/Switch1' */

      L4_MABX_B.Switch1_cw = L4_MABX_B.Add_f;

    } else {

      /* Switch: '<S287>/Switch1' */

      L4_MABX_B.Switch1_cw = L4_MABX_B.UnitDelay_fm;

    }



    L4_MABX_B.Switch1_fi = L4_MABX_B.Switch1_cw;

  }



  /* End of Switch: '<S289>/Switch1' */



  /* DataTypeConversion: '<S286>/Conversion' */

  L4_MABX_B.Conversion = L4_MABX_B.Switch1_fi;



  /* Abs: '<S80>/Abs' */

  L4_MABX_B.Abs_d = fabs(L4_MABX_B.Conversion);



  /* Lookup_n-D: '<S80>/SteeringControlPGainErrorBased' */

  L4_MABX_B.SteeringControlPGainErrorBased = look1_binlxpw(L4_MABX_B.Abs_d,

    L4_MABX_P.SteeringControlPGainErrorBase_n,

    L4_MABX_P.SteeringControlPGainErrorBased_, 9U);



  /* DataTypeConversion: '<S80>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_k = L4_MABX_B.SFunction1_o1_gd;



  /* Lookup_n-D: '<S80>/SteeringControlPGainSpeedFactor' */

  L4_MABX_B.SteeringControlPGainSpeedFactor = look1_binlxpw

    (L4_MABX_B.DataTypeConversion_k, L4_MABX_P.SteeringControlPGainSpeedFact_i,

     L4_MABX_P.SteeringControlPGainSpeedFactor, 8U);



  /* Product: '<S80>/Product1' */

  L4_MABX_B.SteerCtrlPgain = L4_MABX_B.SteeringControlPGainErrorBased *

    L4_MABX_B.SteeringControlPGainSpeedFactor;



  /* Gain: '<S80>/Gain' */

  L4_MABX_B.Gain_c = L4_MABX_P.Gain_Gain_m * L4_MABX_B.SteerCtrlPgain;



  /* Product: '<S296>/Product' */

  L4_MABX_B.Product_d = L4_MABX_B.Conversion * L4_MABX_B.Gain_c;



  /* Product: '<S296>/Divide' incorporates:

   *  Constant: '<S279>/Constant21'

   *  Constant: '<S279>/SteeringControlIntGain'

   */

  L4_MABX_B.Divide_ag = L4_MABX_P.Constant21_Value /

    L4_MABX_P.SteeringControlIntGain_Value;



  /* Product: '<S296>/Product1' */

  L4_MABX_B.Product1_hr = L4_MABX_B.Product_d * L4_MABX_B.Divide_ag;



  /* UnitDelay: '<S295>/Unit Delay' */

  L4_MABX_B.UnitDelay_m5 = L4_MABX_DW.UnitDelay_DSTATE_m;



  /* RelationalOperator: '<S295>/Relational Operator' incorporates:

   *  Constant: '<S279>/Constant19'

   */

  L4_MABX_B.RelationalOperator_dl = (L4_MABX_B.UnitDelay_m5 >=

    L4_MABX_P.Constant19_Value);



  /* Switch: '<S295>/Switch' incorporates:

   *  Constant: '<S295>/Constant3'

   */

  if (L4_MABX_B.RelationalOperator_dl) {

    L4_MABX_B.Switch_o = L4_MABX_P.Constant3_Value_pw;

  } else {

    /* RelationalOperator: '<S295>/Relational Operator1' incorporates:

     *  Constant: '<S279>/Constant20'

     */

    L4_MABX_B.RelationalOperator1_m = (L4_MABX_B.UnitDelay_m5 <=

      L4_MABX_P.Constant20_Value);



    /* Switch: '<S295>/Switch1' incorporates:

     *  Constant: '<S295>/Constant'

     *  Constant: '<S295>/Constant2'

     */

    if (L4_MABX_B.RelationalOperator1_m) {

      L4_MABX_B.Switch1_m = L4_MABX_P.Constant2_Value_hu;

    } else {

      L4_MABX_B.Switch1_m = L4_MABX_P.Constant_Value_i;

    }



    /* End of Switch: '<S295>/Switch1' */

    L4_MABX_B.Switch_o = L4_MABX_B.Switch1_m;

  }



  /* End of Switch: '<S295>/Switch' */



  /* RelationalOperator: '<S298>/Relational Operator5' incorporates:

   *  Constant: '<S298>/Constant5'

   */

  L4_MABX_B.RelationalOperator5_f = (L4_MABX_B.Switch_o !=

    L4_MABX_P.Constant5_Value_o);



  /* Signum: '<S298>/Sign1' */

  PositionFinalLimited = L4_MABX_B.Product1_hr;

  if (PositionFinalLimited < 0.0) {

    L4_MABX_B.Sign1 = -1.0;

  } else if (PositionFinalLimited > 0.0) {

    L4_MABX_B.Sign1 = 1.0;

  } else if (PositionFinalLimited == 0.0) {

    L4_MABX_B.Sign1 = 0.0;

  } else {

    L4_MABX_B.Sign1 = (rtNaN);

  }



  /* End of Signum: '<S298>/Sign1' */



  /* RelationalOperator: '<S298>/Relational Operator4' incorporates:

   *  Constant: '<S298>/Constant4'

   */

  L4_MABX_B.RelationalOperator4_la = (L4_MABX_P.Constant4_Value_j ==

    L4_MABX_B.Sign1);



  /* RelationalOperator: '<S298>/Relational Operator2' incorporates:

   *  Constant: '<S298>/Constant2'

   */

  L4_MABX_B.RelationalOperator2_o = (L4_MABX_B.Switch_o !=

    L4_MABX_P.Constant2_Value_g);



  /* Logic: '<S298>/Logical Operator1' */

  L4_MABX_B.LogicalOperator1_ji = (L4_MABX_B.RelationalOperator4_la &&

    L4_MABX_B.RelationalOperator2_o);



  /* RelationalOperator: '<S298>/Relational Operator1' incorporates:

   *  Constant: '<S298>/Constant1'

   */

  L4_MABX_B.RelationalOperator1_ie = (L4_MABX_B.Switch_o !=

    L4_MABX_P.Constant1_Value_ly);



  /* RelationalOperator: '<S298>/Relational Operator3' incorporates:

   *  Constant: '<S298>/Constant3'

   */

  L4_MABX_B.RelationalOperator3_p = (L4_MABX_P.Constant3_Value_g ==

    L4_MABX_B.Sign1);



  /* Logic: '<S298>/Logical Operator2' */

  L4_MABX_B.LogicalOperator2_o = (L4_MABX_B.RelationalOperator1_ie &&

    L4_MABX_B.RelationalOperator3_p);



  /* Logic: '<S298>/Logical Operator' */

  L4_MABX_B.LogicalOperator_bs = (L4_MABX_B.LogicalOperator1_ji ||

    L4_MABX_B.LogicalOperator2_o);



  /* Logic: '<S298>/Logical Operator3' */

  L4_MABX_B.LogicalOperator3_oi = (L4_MABX_B.RelationalOperator5_f &&

    L4_MABX_B.LogicalOperator_bs);



  /* Switch: '<S298>/Switch1' incorporates:

   *  Constant: '<S298>/Constant'

   */

  if (L4_MABX_B.LogicalOperator3_oi) {

    L4_MABX_B.Switch1_jw = L4_MABX_B.Product1_hr;

  } else {

    L4_MABX_B.Switch1_jw = L4_MABX_P.Constant_Value_o;

  }



  /* End of Switch: '<S298>/Switch1' */



  /* UnitDelay: '<S296>/Unit Delay' */

  L4_MABX_B.UnitDelay_o = L4_MABX_DW.UnitDelay_DSTATE_m0;



  /* Sum: '<S296>/Add' */

  L4_MABX_B.Add_px = L4_MABX_B.Switch1_jw + L4_MABX_B.UnitDelay_o;



  /* Product: '<S296>/Divide1' incorporates:

   *  Constant: '<S279>/Constant21'

   *  Constant: '<S279>/SteeringControlDGain'

   */

  L4_MABX_B.Divide1_b = L4_MABX_P.SteeringControlDGain_Value *

    L4_MABX_B.Product_d / L4_MABX_P.Constant21_Value;



  /* UnitDelay: '<S296>/Unit Delay1' */

  L4_MABX_B.UnitDelay1_e = L4_MABX_DW.UnitDelay1_DSTATE_k;



  /* Sum: '<S296>/Add3' */

  L4_MABX_B.Add3 = L4_MABX_B.Divide1_b - L4_MABX_B.UnitDelay1_e;



  /* Sum: '<S296>/Add1' */

  L4_MABX_B.Add1_m = (L4_MABX_B.Product_d + L4_MABX_B.Add_px) + L4_MABX_B.Add3;



  /* RelationalOperator: '<S297>/LowerRelop1' incorporates:

   *  Constant: '<S279>/Constant19'

   */

  L4_MABX_B.LowerRelop1 = (L4_MABX_B.Add1_m > L4_MABX_P.Constant19_Value);



  /* RelationalOperator: '<S297>/UpperRelop' incorporates:

   *  Constant: '<S279>/Constant20'

   */

  L4_MABX_B.UpperRelop = (L4_MABX_B.Add1_m < L4_MABX_P.Constant20_Value);



  /* Switch: '<S297>/Switch' incorporates:

   *  Constant: '<S279>/Constant20'

   */

  if (L4_MABX_B.UpperRelop) {

    L4_MABX_B.Switch_p = L4_MABX_P.Constant20_Value;

  } else {

    L4_MABX_B.Switch_p = L4_MABX_B.Add1_m;

  }



  /* End of Switch: '<S297>/Switch' */



  /* Switch: '<S297>/Switch2' incorporates:

   *  Constant: '<S279>/Constant19'

   */

  if (L4_MABX_B.LowerRelop1) {

    L4_MABX_B.Switch2_i = L4_MABX_P.Constant19_Value;

  } else {

    L4_MABX_B.Switch2_i = L4_MABX_B.Switch_p;

  }



  /* End of Switch: '<S297>/Switch2' */



  /* RateTransition: '<S80>/TmpRTBAtrad2deg1Inport1' */

  if (L4_MABX_M->Timing.RateInteraction.TID0_1 == 1) {

    L4_MABX_B.previewSteeringAngle_b =

      L4_MABX_DW.TmpRTBAtrad2deg1Inport1_Buffer0;

  }



  /* Gain: '<S80>/rad2deg1' */

  L4_MABX_B.rad2deg1 = L4_MABX_P.rad2deg1_Gain *

    L4_MABX_B.previewSteeringAngle_b;



  /* Sum: '<S80>/Add2' incorporates:

   *  Constant: '<S80>/steeringOffset'

   */

  L4_MABX_B.Add2 = (L4_MABX_B.rad2deg1 + L4_MABX_B.Switch2_i) +

    L4_MABX_P.steeringOffset_Value;



  /* Lookup_n-D: '<S284>/1-D Lookup Table' */

  L4_MABX_B.uDLookupTable_a = look1_binlxpw(L4_MABX_B.DataTypeConversion_k,

    L4_MABX_P.uDLookupTable_bp01Data_k, L4_MABX_P.uDLookupTable_tableData_b, 8U);



  /* Product: '<S284>/AdjustedStanleyGain' incorporates:

   *  Constant: '<S284>/stanleySteeringControlGain'

   */

  L4_MABX_B.AdjustedStanleyGain = L4_MABX_B.uDLookupTable_a *

    L4_MABX_P.stanleySteeringControlGain_Valu;



  /* Step: '<S278>/Step' */

  PositionFinalLimited = L4_MABX_M->Timing.t[0];

  if (PositionFinalLimited < L4_MABX_P.Step_Time) {

    L4_MABX_B.Step = L4_MABX_P.Step_Y0;

  } else {

    L4_MABX_B.Step = L4_MABX_P.Step_YFinal;

  }



  /* End of Step: '<S278>/Step' */



  /* DataTypeConversion: '<S278>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_dn = (L4_MABX_B.Step != 0.0);



  /* Product: '<S290>/Divide' incorporates:

   *  Constant: '<S278>/Constant'

   *  Constant: '<S278>/Constant1'

   */

  L4_MABX_B.Divide_d0 = (real32_T)(L4_MABX_P.Constant1_Value_iy /

    L4_MABX_P.Constant_Value_d);



  /* RateTransition: '<S80>/TmpRTBAtsignCurveOffsetInport1' */

  if (L4_MABX_M->Timing.RateInteraction.TID0_1 == 1) {

    L4_MABX_B.TmpRTBAtsignCurveOffsetInport1 =

      L4_MABX_DW.TmpRTBAtsignCurveOffsetInport1_;

  }



  /* Gain: '<S80>/signCurveOffset' */

  L4_MABX_B.signCurveOffset = L4_MABX_P.signCurveOffset_Gain *

    L4_MABX_B.TmpRTBAtsignCurveOffsetInport1;



  /* UnitDelay: '<S290>/Unit Delay' */

  L4_MABX_B.UnitDelay_lj = L4_MABX_DW.UnitDelay_DSTATE_m1;



  /* Switch: '<S294>/Switch1' incorporates:

   *  Constant: '<S290>/E'

   *  Switch: '<S292>/Switch1'

   */

  if (L4_MABX_B.DataTypeConversion_dn) {

    /* DataTypeConversion: '<S290>/Data Type Conversion1' incorporates:

     *  Constant: '<S290>/IV'

     */

    L4_MABX_B.DataTypeConversion1_g = (real32_T)L4_MABX_P.IV_Value_o;

    L4_MABX_B.Switch1_pb = L4_MABX_B.DataTypeConversion1_g;

  } else {

    if (L4_MABX_P.E_Value_ct) {

      /* DataTypeConversion: '<S290>/Data Type Conversion' incorporates:

       *  Switch: '<S292>/Switch1'

       */

      L4_MABX_B.DataTypeConversion_m = (real32_T)L4_MABX_B.signCurveOffset;



      /* Sum: '<S290>/Add3' incorporates:

       *  Switch: '<S292>/Switch1'

       */

      L4_MABX_B.Add3_p = L4_MABX_B.DataTypeConversion_m - L4_MABX_B.UnitDelay_lj;



      /* Product: '<S290>/Product1' incorporates:

       *  Switch: '<S292>/Switch1'

       */

      L4_MABX_B.Product1_ce = L4_MABX_B.Divide_d0 * L4_MABX_B.Add3_p;



      /* Sum: '<S290>/Add' incorporates:

       *  Switch: '<S292>/Switch1'

       */

      L4_MABX_B.Add_a = L4_MABX_B.Product1_ce + L4_MABX_B.UnitDelay_lj;



      /* Switch: '<S292>/Switch1' */

      L4_MABX_B.Switch1_aq = L4_MABX_B.Add_a;

    } else {

      /* Switch: '<S292>/Switch1' */

      L4_MABX_B.Switch1_aq = L4_MABX_B.UnitDelay_lj;

    }



    L4_MABX_B.Switch1_pb = L4_MABX_B.Switch1_aq;

  }



  /* End of Switch: '<S294>/Switch1' */



  /* DataTypeConversion: '<S291>/Conversion' */

  L4_MABX_B.Conversion_b = L4_MABX_B.Switch1_pb;



  /* Gain: '<S80>/mm2m' */

  L4_MABX_B.mm2m = L4_MABX_P.mm2m_Gain * L4_MABX_B.correctedError;



  /* Switch: '<S80>/Switch3' incorporates:

   *  Constant: '<S80>/usePIDyForStanley'

   */

  if (L4_MABX_P.usePIDyForStanley_Value != 0.0) {

    L4_MABX_B.Switch3 = L4_MABX_B.Switch2_i;

  } else {

    L4_MABX_B.Switch3 = L4_MABX_B.mm2m;

  }



  /* End of Switch: '<S80>/Switch3' */



  /* Gain: '<S80>/sign3' */

  L4_MABX_B.sign3 = L4_MABX_P.sign3_Gain * L4_MABX_B.Switch3;



  /* Sum: '<S80>/crossTrackError' */

  L4_MABX_B.crossTrackError = L4_MABX_B.Conversion_b + L4_MABX_B.sign3;



  /* Product: '<S284>/Product' */

  L4_MABX_B.Product_p = L4_MABX_B.AdjustedStanleyGain *

    L4_MABX_B.crossTrackError;



  /* Saturate: '<S284>/Saturation' */

  DeltaTime = L4_MABX_B.DataTypeConversion_k;

  Time56 = L4_MABX_P.Saturation_LowerSat_bq;

  AccelerationAverage = L4_MABX_P.Saturation_UpperSat_e;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Saturation_a = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Saturation_a = Time56;

  } else {

    L4_MABX_B.Saturation_a = DeltaTime;

  }



  /* End of Saturate: '<S284>/Saturation' */



  /* Gain: '<S284>/kph2mps_' */

  L4_MABX_B.kph2mps_ = L4_MABX_P.kph2mps_Gain * L4_MABX_B.Saturation_a;



  /* Trigonometry: '<S284>/Trigonometric Function' */

  L4_MABX_B.TrigonometricFunction_p = rt_atan2d_snf(L4_MABX_B.Product_p,

    L4_MABX_B.kph2mps_);



  /* Gain: '<S80>/deg2rad1' */

  L4_MABX_B.deg2rad1 = L4_MABX_P.deg2rad1_Gain * L4_MABX_B.uDLookupTable1;



  /* RateTransition: '<S284>/TmpRTBAtAdd2Inport2' */

  if (L4_MABX_M->Timing.RateInteraction.TID0_1 == 1) {

    L4_MABX_B.TmpRTBAtAdd2Inport2 = L4_MABX_DW.TmpRTBAtAdd2Inport2_Buffer0;

  }



  /* Sum: '<S284>/Add2' */

  L4_MABX_B.Add2_g = L4_MABX_B.deg2rad1 - L4_MABX_B.TmpRTBAtAdd2Inport2;



  /* Gain: '<S284>/desHeadingWeight' */

  L4_MABX_B.desHeadingWeight = L4_MABX_P.desHeadingWeight_Gain *

    L4_MABX_B.Add2_g;



  /* Sum: '<S284>/Add1' */

  L4_MABX_B.Add1_hl = L4_MABX_B.TrigonometricFunction_p +

    L4_MABX_B.desHeadingWeight;



  /* DataTypeConversion: '<S316>/Data Type Conversion' incorporates:

   *  Constant: '<S316>/RATE_LIMITER_ENABLE_APV'

   */

  L4_MABX_B.DataTypeConversion_l5 = (real_T)RATE_LIMITER_ENABLE_APV;



  /* Lookup_n-D: '<S316>/Saturation Speed Lookup' */

  L4_MABX_B.SaturationSpeedLookup = look1_binlcapw

    (L4_MABX_B.DataTypeConversion_k, L4_MABX_P.SaturationSpeedLookup_bp01Data,

     L4_MABX_P.SaturationSpeedLookup_tableData, 5U);



  /* Constant: '<S316>/Constant' */

  Lateral_Control_Rate_Limit = Lateral_Control_Rate_Limit_APV;



  /* SampleTimeMath: '<S327>/sample time'

   *

   * About '<S327>/sample time':

   *  y = K where K = ( w * Ts )

   */

  L4_MABX_B.sampletime = L4_MABX_P.sampletime_WtEt;



  /* Product: '<S327>/delta rise limit' */

  L4_MABX_B.deltariselimit = Lateral_Control_Rate_Limit * L4_MABX_B.sampletime;



  /* SampleTimeMath: '<S314>/sample time'

   *

   * About '<S314>/sample time':

   *  y = K where K = ( w * Ts )

   */

  L4_MABX_B.sampletime_c = L4_MABX_P.sampletime_WtEt_j;



  /* Product: '<S314>/delta rise limit' incorporates:

   *  Constant: '<S281>/Constant7'

   */

  L4_MABX_B.deltariselimit_c = Lateral_Control_Error_Rate_Limit *

    L4_MABX_B.sampletime_c;



  /* MATLAB Function: '<S281>/Error Calc' */

  /* MATLAB Function 'STEERCTRL_10ms/SteerController/Error Calc': '<S309>:1' */

  /* '<S309>:1:3' */

  Lateral_Control_Heading_Error = TargetAzimuth_rad - CurrentAzimuth_rad;

  if (Lateral_Control_Heading_Error < -3.1415926535897931) {

    /* '<S309>:1:5' */

    /* '<S309>:1:6' */

    Lateral_Control_Heading_Error += 6.2831853071795862;

  } else {

    if (Lateral_Control_Heading_Error > 3.1415926535897931) {

      /* '<S309>:1:7' */

      /* '<S309>:1:8' */

      Lateral_Control_Heading_Error -= 6.2831853071795862;

    }

  }



  /* End of MATLAB Function: '<S281>/Error Calc' */



  /* UnitDelay: '<S314>/Delay Input2' */

  L4_MABX_B.Yk1 = L4_MABX_DW.DelayInput2_DSTATE;



  /* Sum: '<S314>/Difference Inputs1' */

  L4_MABX_B.UkYk1 = Lateral_Control_Heading_Error - L4_MABX_B.Yk1;



  /* RelationalOperator: '<S323>/LowerRelop1' */

  L4_MABX_B.LowerRelop1_h = (L4_MABX_B.UkYk1 > L4_MABX_B.deltariselimit_c);



  /* Product: '<S314>/delta fall limit' incorporates:

   *  Constant: '<S281>/Constant8'

   */

  PositionFinalLimited = -Lateral_Control_Error_Rate_Limit;

  L4_MABX_B.deltafalllimit = PositionFinalLimited * L4_MABX_B.sampletime_c;



  /* RelationalOperator: '<S323>/UpperRelop' */

  L4_MABX_B.UpperRelop_f = (L4_MABX_B.UkYk1 < L4_MABX_B.deltafalllimit);



  /* Switch: '<S323>/Switch' */

  if (L4_MABX_B.UpperRelop_f) {

    L4_MABX_B.Switch_iv = L4_MABX_B.deltafalllimit;

  } else {

    L4_MABX_B.Switch_iv = L4_MABX_B.UkYk1;

  }



  /* End of Switch: '<S323>/Switch' */



  /* Switch: '<S323>/Switch2' */

  if (L4_MABX_B.LowerRelop1_h) {

    L4_MABX_B.Switch2_f = L4_MABX_B.deltariselimit_c;

  } else {

    L4_MABX_B.Switch2_f = L4_MABX_B.Switch_iv;

  }



  /* End of Switch: '<S323>/Switch2' */



  /* Sum: '<S314>/Difference Inputs2' */

  L4_MABX_B.DifferenceInputs2 = L4_MABX_B.Switch2_f + L4_MABX_B.Yk1;



  /* RelationalOperator: '<S310>/Relational Operator1' incorporates:

   *  Constant: '<S281>/Constant'

   */

  L4_MABX_B.RelationalOperator1_ps = (L4_MABX_B.DifferenceInputs2 >=

    Lateral_Control_Error_Limit);



  /* RelationalOperator: '<S310>/Relational Operator' incorporates:

   *  Constant: '<S281>/Constant1'

   */

  PositionFinalLimited = -Lateral_Control_Error_Limit;

  L4_MABX_B.RelationalOperator_hy = (L4_MABX_B.DifferenceInputs2 <=

    PositionFinalLimited);



  /* Outputs for Atomic SubSystem: '<S310>/If_Then_Else1' */

  /* Constant: '<S281>/Constant1' */

  PositionFinalLimited = -Lateral_Control_Error_Limit;

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator_hy, PositionFinalLimited,

                       L4_MABX_B.DifferenceInputs2, &L4_MABX_B.If_Then_Else1_k);



  /* End of Outputs for SubSystem: '<S310>/If_Then_Else1' */



  /* Outputs for Atomic SubSystem: '<S310>/If_Then_Else' */



  /* Constant: '<S281>/Constant' */

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator1_ps,

                       Lateral_Control_Error_Limit,

                       L4_MABX_B.If_Then_Else1_k.Switch,

                       &L4_MABX_B.If_Then_Else_pn);



  /* End of Outputs for SubSystem: '<S310>/If_Then_Else' */



  /* Outputs for Atomic SubSystem: '<S281>/If_Then_Else1' */



  /* Constant: '<S281>/Zero' */

  L4_MABX_If_Then_Else_g(L4_MABX_B.AutonomousEnabled_d,

    L4_MABX_B.If_Then_Else_pn.Switch, L4_MABX_P.Zero_Value,

    &L4_MABX_B.If_Then_Else1_m);



  /* End of Outputs for SubSystem: '<S281>/If_Then_Else1' */



  /* Gain: '<S313>/Proportional Gain' */

  L4_MABX_B.ProportionalGain = Lateral_Control_P *

    L4_MABX_B.If_Then_Else1_m.Switch;



  /* DiscreteIntegrator: '<S313>/Integrator' */

  if (L4_MABX_B.AutonomousEnabled_d && (L4_MABX_DW.Integrator_PrevResetState <=

       0)) {

    L4_MABX_DW.Integrator_DSTATE = L4_MABX_P.Integrator_IC;

  }



  L4_MABX_B.Integrator = L4_MABX_DW.Integrator_DSTATE;



  /* End of DiscreteIntegrator: '<S313>/Integrator' */



  /* Gain: '<S313>/Derivative Gain' */

  L4_MABX_B.DerivativeGain = Lateral_Control_D *

    L4_MABX_B.If_Then_Else1_m.Switch;



  /* DiscreteIntegrator: '<S313>/Filter' */

  if (L4_MABX_B.AutonomousEnabled_d && (L4_MABX_DW.Filter_PrevResetState <= 0))

  {

    L4_MABX_DW.Filter_DSTATE = L4_MABX_P.Filter_IC;

  }



  L4_MABX_B.Filter = L4_MABX_DW.Filter_DSTATE;



  /* End of DiscreteIntegrator: '<S313>/Filter' */



  /* Sum: '<S313>/SumD' */

  L4_MABX_B.SumD = L4_MABX_B.DerivativeGain - L4_MABX_B.Filter;



  /* Gain: '<S313>/Filter Coefficient' */

  L4_MABX_B.FilterCoefficient = L4_MABX_P.PIDController_N * L4_MABX_B.SumD;



  /* Sum: '<S313>/Sum' */

  L4_MABX_B.Sum_c = (L4_MABX_B.ProportionalGain + L4_MABX_B.Integrator) +

    L4_MABX_B.FilterCoefficient;



  /* Saturate: '<S313>/Saturate' */

  DeltaTime = L4_MABX_B.Sum_c;

  Time56 = L4_MABX_P.PIDController_LowerSaturationLi;

  AccelerationAverage = L4_MABX_P.PIDController_UpperSaturationLi;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Saturate = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.Saturate = Time56;

  } else {

    L4_MABX_B.Saturate = DeltaTime;

  }



  /* End of Saturate: '<S313>/Saturate' */



  /* UnitDelay: '<S317>/Delay Input' */

  L4_MABX_B.Uk1_m = L4_MABX_DW.DelayInput_DSTATE;



  /* Gain: '<S317>/GainZero' */

  L4_MABX_B.ZeroUk1 = Lateral_Control_Zero * L4_MABX_B.Uk1_m;



  /* UnitDelay: '<S317>/Delay Output' */

  L4_MABX_B.Yk1_p = L4_MABX_DW.DelayOutput_DSTATE;



  /* Gain: '<S317>/GainPole' */

  L4_MABX_B.PoleYk1 = Lateral_Control_Pole * L4_MABX_B.Yk1_p;



  /* Sum: '<S317>/Sum' */

  L4_MABX_B.PoleYk1UkZeroUk1 = (L4_MABX_B.Saturate - L4_MABX_B.ZeroUk1) +

    L4_MABX_B.PoleYk1;



  /* DataTypeConversion: '<S317>/Downcast' */

  L4_MABX_B.Downcast = L4_MABX_B.PoleYk1UkZeroUk1;



  /* Sum: '<S281>/Subtract' incorporates:

   *  Constant: '<S281>/Constant6'

   */

  L4_MABX_B.Subtract_c = ReAX_ActualHandwheelPos - REAX_OFFSET_APV;



  /* Lookup_n-D: '<S281>/1-D Lookup Table' */

  L4_MABX_B.uDLookupTable_j = look1_binlxpw(L4_MABX_B.Subtract_c,

    L4_MABX_P.uDLookupTable_bp01Data_d, L4_MABX_P.uDLookupTable_tableData_d, 71U);



  /* Gain: '<S281>/deg2rad' */

  L4_MABX_B.deg2rad = L4_MABX_P.deg2rad_Gain_l * L4_MABX_B.uDLookupTable_j;



  /* Gain: '<S281>/invert' */

  L4_MABX_B.invert = L4_MABX_P.invert_Gain * L4_MABX_B.deg2rad;



  /* Gain: '<S281>/PGain' */

  L4_MABX_B.PGain = Lateral_Control_P * L4_MABX_B.If_Then_Else_pn.Switch;



  /* SampleTimeMath: '<S315>/sample time'

   *

   * About '<S315>/sample time':

   *  y = K where K = ( w * Ts )

   */

  L4_MABX_B.sampletime_a = L4_MABX_P.sampletime_WtEt_p;



  /* Product: '<S315>/delta rise limit' incorporates:

   *  Constant: '<S281>/Constant9'

   */

  L4_MABX_B.deltariselimit_o = Lateral_Control_Error_Rate_Limit *

    L4_MABX_B.sampletime_a;



  /* Sum: '<S281>/Sum' incorporates:

   *  Constant: '<S281>/YAW_RATE_OFFSET_APV'

   */

  L4_MABX_B.Sum_ly = YawRate + YAW_RATE_OFFSET_APV;



  /* RelationalOperator: '<S318>/Relational Operator1' incorporates:

   *  Constant: '<S281>/Constant2'

   */

  L4_MABX_B.RelationalOperator1_f = (L4_MABX_B.Sum_ly >=

    Lateral_Control_YawRate_Limit);



  /* RelationalOperator: '<S318>/Relational Operator' incorporates:

   *  Constant: '<S281>/Constant4'

   */

  PositionFinalLimited = -Lateral_Control_YawRate_Limit;

  L4_MABX_B.RelationalOperator_l4 = (L4_MABX_B.Sum_ly <= PositionFinalLimited);



  /* Outputs for Atomic SubSystem: '<S318>/If_Then_Else1' */

  /* Constant: '<S281>/Constant4' */

  PositionFinalLimited = -Lateral_Control_YawRate_Limit;

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator_l4, PositionFinalLimited,

                       L4_MABX_B.Sum_ly, &L4_MABX_B.If_Then_Else1_o0);



  /* End of Outputs for SubSystem: '<S318>/If_Then_Else1' */



  /* Outputs for Atomic SubSystem: '<S318>/If_Then_Else' */



  /* Constant: '<S281>/Constant2' */

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator1_f,

                       Lateral_Control_YawRate_Limit,

                       L4_MABX_B.If_Then_Else1_o0.Switch,

                       &L4_MABX_B.If_Then_Else_m0);



  /* End of Outputs for SubSystem: '<S318>/If_Then_Else' */



  /* Gain: '<S281>/RateFeedbackGain' */

  L4_MABX_B.RateFeedbackGain = Yaw_Rate_FF_Gain *

    L4_MABX_B.If_Then_Else_m0.Switch;



  /* MultiPortSwitch: '<S281>/Multiport Switch2' incorporates:

   *  Constant: '<S281>/Understeer Corection'

   *  Constant: '<S281>/Use Gain Schedule'

   */

  if (LATERAL_GAIN_SCHEDULE_APV == ENUM_SWITCH_T_ON) {

    /* Lookup_n-D: '<S281>/Speed Lookup Table' */

    L4_MABX_B.SpeedLookupTable = look1_binlcapw(L4_MABX_B.DataTypeConversion_k,

      L4_MABX_P.SpeedLookupTable_bp01Data_i,

      L4_MABX_P.SpeedLookupTable_tableData_k, 3U);

    L4_MABX_B.MultiportSwitch2 = L4_MABX_B.SpeedLookupTable;

  } else {

    L4_MABX_B.MultiportSwitch2 = UndersteerCorection;

  }



  /* End of MultiPortSwitch: '<S281>/Multiport Switch2' */



  /* RelationalOperator: '<S308>/Relational Operator1' incorporates:

   *  Constant: '<S281>/Constant3'

   */

  L4_MABX_B.RelationalOperator1_gr = (Curvature >=

    Lateral_Control_Curvature_Limit);



  /* RelationalOperator: '<S308>/Relational Operator' incorporates:

   *  Constant: '<S281>/Constant5'

   */

  PositionFinalLimited = -Lateral_Control_Curvature_Limit;

  L4_MABX_B.RelationalOperator_o = (Curvature <= PositionFinalLimited);



  /* Outputs for Atomic SubSystem: '<S308>/If_Then_Else1' */

  /* Constant: '<S281>/Constant5' */

  PositionFinalLimited = -Lateral_Control_Curvature_Limit;

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator_o, PositionFinalLimited,

                       Curvature, &L4_MABX_B.If_Then_Else1_d);



  /* End of Outputs for SubSystem: '<S308>/If_Then_Else1' */



  /* Outputs for Atomic SubSystem: '<S308>/If_Then_Else' */



  /* Constant: '<S281>/Constant3' */

  L4_MABX_If_Then_Else(L4_MABX_B.RelationalOperator1_gr,

                       Lateral_Control_Curvature_Limit,

                       L4_MABX_B.If_Then_Else1_d.Switch,

                       &L4_MABX_B.If_Then_Else_pe);



  /* End of Outputs for SubSystem: '<S308>/If_Then_Else' */



  /* Gain: '<S281>/FeedforwardGain' */

  L4_MABX_B.FeedforwardGain = L4_MABX_P.FeedforwardGain_Gain *

    L4_MABX_B.If_Then_Else_pe.Switch;



  /* Product: '<S281>/Multiply' */

  L4_MABX_B.Multiply = L4_MABX_B.MultiportSwitch2 * L4_MABX_B.FeedforwardGain;



  /* Sum: '<S281>/Sum2' */

  L4_MABX_B.Sum2 = L4_MABX_B.Multiply - L4_MABX_B.RateFeedbackGain;



  /* UnitDelay: '<S315>/Delay Input2' */

  L4_MABX_B.Yk1_o = L4_MABX_DW.DelayInput2_DSTATE_a;



  /* Sum: '<S315>/Difference Inputs1' */

  L4_MABX_B.UkYk1_n = L4_MABX_B.Sum2 - L4_MABX_B.Yk1_o;



  /* RelationalOperator: '<S324>/LowerRelop1' */

  L4_MABX_B.LowerRelop1_o = (L4_MABX_B.UkYk1_n > L4_MABX_B.deltariselimit_o);



  /* Product: '<S315>/delta fall limit' incorporates:

   *  Constant: '<S281>/Constant10'

   */

  PositionFinalLimited = -Lateral_Control_Error_Rate_Limit;

  L4_MABX_B.deltafalllimit_o = PositionFinalLimited * L4_MABX_B.sampletime_a;



  /* RelationalOperator: '<S324>/UpperRelop' */

  L4_MABX_B.UpperRelop_o = (L4_MABX_B.UkYk1_n < L4_MABX_B.deltafalllimit_o);



  /* Switch: '<S324>/Switch' */

  if (L4_MABX_B.UpperRelop_o) {

    L4_MABX_B.Switch_e = L4_MABX_B.deltafalllimit_o;

  } else {

    L4_MABX_B.Switch_e = L4_MABX_B.UkYk1_n;

  }



  /* End of Switch: '<S324>/Switch' */



  /* Switch: '<S324>/Switch2' */

  if (L4_MABX_B.LowerRelop1_o) {

    L4_MABX_B.Switch2_e = L4_MABX_B.deltariselimit_o;

  } else {

    L4_MABX_B.Switch2_e = L4_MABX_B.Switch_e;

  }



  /* End of Switch: '<S324>/Switch2' */



  /* Sum: '<S315>/Difference Inputs2' */

  L4_MABX_B.DifferenceInputs2_a = L4_MABX_B.Switch2_e + L4_MABX_B.Yk1_o;



  /* Sum: '<S281>/Sum3' */

  L4_MABX_B.Sum3 = (L4_MABX_B.invert - L4_MABX_B.PGain) -

    L4_MABX_B.DifferenceInputs2_a;



  /* DiscreteIntegrator: '<S307>/Discrete-Time Integrator' */

  if (L4_MABX_DW.DiscreteTimeIntegrator_IC_LOADI != 0) {

    L4_MABX_DW.DiscreteTimeIntegrator_DSTATE = L4_MABX_B.Sum3;

  }



  if (L4_MABX_B.AutonomousEnabled_d &&

      (L4_MABX_DW.DiscreteTimeIntegrator_PrevRese <= 0)) {

    L4_MABX_DW.DiscreteTimeIntegrator_DSTATE = L4_MABX_B.Sum3;

  }



  L4_MABX_B.DiscreteTimeIntegrator = L4_MABX_DW.DiscreteTimeIntegrator_DSTATE;



  /* End of DiscreteIntegrator: '<S307>/Discrete-Time Integrator' */



  /* Sum: '<S281>/Sum4' */

  L4_MABX_B.Sum4 = L4_MABX_B.Downcast + L4_MABX_B.DiscreteTimeIntegrator;



  /* Sum: '<S281>/Sum1' */

  Lateral_Control_Output = L4_MABX_B.Sum4 + L4_MABX_B.DifferenceInputs2_a;



  /* UnitDelay: '<S327>/Delay Input2' */

  L4_MABX_B.Yk1_pm = L4_MABX_DW.DelayInput2_DSTATE_l;



  /* Sum: '<S327>/Difference Inputs1' */

  L4_MABX_B.UkYk1_f = Lateral_Control_Output - L4_MABX_B.Yk1_pm;



  /* RelationalOperator: '<S329>/LowerRelop1' */

  L4_MABX_B.LowerRelop1_l = (L4_MABX_B.UkYk1_f > L4_MABX_B.deltariselimit);



  /* Gain: '<S316>/Gain3' */

  L4_MABX_B.RateLimitLower = L4_MABX_P.Gain3_Gain_p * Lateral_Control_Rate_Limit;



  /* Product: '<S327>/delta fall limit' */

  L4_MABX_B.deltafalllimit_n = L4_MABX_B.RateLimitLower * L4_MABX_B.sampletime;



  /* RelationalOperator: '<S329>/UpperRelop' */

  L4_MABX_B.UpperRelop_k = (L4_MABX_B.UkYk1_f < L4_MABX_B.deltafalllimit_n);



  /* Switch: '<S329>/Switch' */

  if (L4_MABX_B.UpperRelop_k) {

    L4_MABX_B.Switch_f = L4_MABX_B.deltafalllimit_n;

  } else {

    L4_MABX_B.Switch_f = L4_MABX_B.UkYk1_f;

  }



  /* End of Switch: '<S329>/Switch' */



  /* Switch: '<S329>/Switch2' */

  if (L4_MABX_B.LowerRelop1_l) {

    L4_MABX_B.Switch2_fa = L4_MABX_B.deltariselimit;

  } else {

    L4_MABX_B.Switch2_fa = L4_MABX_B.Switch_f;

  }



  /* End of Switch: '<S329>/Switch2' */



  /* Sum: '<S327>/Difference Inputs2' */

  L4_MABX_B.DifferenceInputs2_m = L4_MABX_B.Switch2_fa + L4_MABX_B.Yk1_pm;



  /* RelationalOperator: '<S328>/LowerRelop1' */

  L4_MABX_B.LowerRelop1_e = (L4_MABX_B.DifferenceInputs2_m >

    L4_MABX_B.SaturationSpeedLookup);



  /* Gain: '<S316>/Gain1' */

  L4_MABX_B.Gain1_f = L4_MABX_P.Gain1_Gain_p * L4_MABX_B.SaturationSpeedLookup;



  /* RelationalOperator: '<S328>/UpperRelop' */

  L4_MABX_B.UpperRelop_fl = (L4_MABX_B.DifferenceInputs2_m < L4_MABX_B.Gain1_f);



  /* Switch: '<S328>/Switch' */

  if (L4_MABX_B.UpperRelop_fl) {

    L4_MABX_B.Switch_hx = L4_MABX_B.Gain1_f;

  } else {

    L4_MABX_B.Switch_hx = L4_MABX_B.DifferenceInputs2_m;

  }



  /* End of Switch: '<S328>/Switch' */



  /* Switch: '<S328>/Switch2' */

  if (L4_MABX_B.LowerRelop1_e) {

    L4_MABX_B.Switch2_k = L4_MABX_B.SaturationSpeedLookup;

  } else {

    L4_MABX_B.Switch2_k = L4_MABX_B.Switch_hx;

  }



  /* End of Switch: '<S328>/Switch2' */



  /* Outputs for Atomic SubSystem: '<S316>/If_Then_Else' */

  L4_MABX_If_Then_Else_k(L4_MABX_B.DataTypeConversion_l5, L4_MABX_B.Switch2_k,

    Lateral_Control_Output, &L4_MABX_B.If_Then_Else_c);



  /* End of Outputs for SubSystem: '<S316>/If_Then_Else' */



  /* SignalConversion: '<S316>/TmpSignal ConversionAtIf_Then_ElseOutport1' */

  Lateral_Control_Rate_Limiter_Output = L4_MABX_B.If_Then_Else_c.Switch;



  /* Outputs for Atomic SubSystem: '<S281>/If_Then_Else' */

  L4_MABX_If_Then_Else_g(L4_MABX_B.AutonomousEnabled_d,

    Lateral_Control_Rate_Limiter_Output, L4_MABX_B.invert,

    &L4_MABX_B.If_Then_Else_m);



  /* End of Outputs for SubSystem: '<S281>/If_Then_Else' */



  /* DataTypeConversion: '<S301>/Data Type Conversion' incorporates:

   *  Constant: '<S301>/RATE_LIMITER_ENABLE_APV'

   */

  L4_MABX_B.DataTypeConversion_g = (real_T)RATE_LIMITER_ENABLE_APV;



  /* Saturate: '<S280>/Speed Saturation' */

  DeltaTime = L4_MABX_B.DataTypeConversion_k;

  Time56 = L4_MABX_P.SpeedSaturation_LowerSat;

  AccelerationAverage = L4_MABX_P.SpeedSaturation_UpperSat;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.SpeedSaturation = AccelerationAverage;

  } else if (DeltaTime < Time56) {

    L4_MABX_B.SpeedSaturation = Time56;

  } else {

    L4_MABX_B.SpeedSaturation = DeltaTime;

  }



  /* End of Saturate: '<S280>/Speed Saturation' */



  /* Lookup_n-D: '<S301>/Saturation Speed Lookup' */

  L4_MABX_B.SaturationSpeedLookup_d = look1_binlcapw(L4_MABX_B.SpeedSaturation,

    L4_MABX_P.SaturationSpeedLookup_bp01Dat_h,

    L4_MABX_P.SaturationSpeedLookup_tableDa_p, 5U);



  /* MultiPortSwitch: '<S301>/Multiport Switch2' incorporates:

   *  Constant: '<S301>/Constant'

   *  Constant: '<S301>/Use Gain Schedule'

   */

  if (LATERAL_GAIN_SCHEDULE_APV == ENUM_SWITCH_T_ON) {

    /* Lookup_n-D: '<S301>/Speed Lookup Table' */

    L4_MABX_B.RateSpeed_d = look1_binlcapw(L4_MABX_B.SpeedSaturation,

      L4_MABX_P.SpeedLookupTable_bp01Data_f,

      L4_MABX_P.SpeedLookupTable_tableData_c, 2U);

    Stanley_Rate_Limit = L4_MABX_B.RateSpeed_d;

  } else {

    Stanley_Rate_Limit = Lateral_Control_Rate_Limit_APV;

  }



  /* End of MultiPortSwitch: '<S301>/Multiport Switch2' */



  /* SampleTimeMath: '<S304>/sample time'

   *

   * About '<S304>/sample time':

   *  y = K where K = ( w * Ts )

   */

  L4_MABX_B.sampletime_ca = L4_MABX_P.sampletime_WtEt_e;



  /* Product: '<S304>/delta rise limit' */

  L4_MABX_B.deltariselimit_cn = Stanley_Rate_Limit * L4_MABX_B.sampletime_ca;



  /* MATLAB Function: '<S280>/Error Calc' */

  /* MATLAB Function 'STEERCTRL_10ms/StanleyController/Error Calc': '<S299>:1' */

  /* '<S299>:1:3' */

  L4_MABX_B.error = TargetAzimuth_rad - CurrentAzimuth_rad;

  if (L4_MABX_B.error < -3.1415926535897931) {

    /* '<S299>:1:5' */

    /* '<S299>:1:6' */

    L4_MABX_B.error += 6.2831853071795862;

  } else {

    if (L4_MABX_B.error > 3.1415926535897931) {

      /* '<S299>:1:7' */

      /* '<S299>:1:8' */

      L4_MABX_B.error -= 6.2831853071795862;

    }

  }



  /* End of MATLAB Function: '<S280>/Error Calc' */



  /* Saturate: '<S280>/Error Saturation' */

  PositionFinalLimited = -Lateral_Control_Error_Limit;

  DeltaTime = L4_MABX_B.error;

  AccelerationAverage = Lateral_Control_Error_Limit;

  if (DeltaTime > AccelerationAverage) {

    L4_MABX_B.Lateral_Control_Heading_Error_k = AccelerationAverage;

  } else if (DeltaTime < PositionFinalLimited) {

    L4_MABX_B.Lateral_Control_Heading_Error_k = PositionFinalLimited;

  } else {

    L4_MABX_B.Lateral_Control_Heading_Error_k = DeltaTime;

  }



  /* End of Saturate: '<S280>/Error Saturation' */



  /* Gain: '<S280>/km//h to m//s' */

  L4_MABX_B.kmhtoms = L4_MABX_P.kmhtoms_Gain * L4_MABX_B.SpeedSaturation;



  /* MultiPortSwitch: '<S280>/Multiport Switch1' incorporates:

   *  Constant: '<S280>/Stanley Gain K'

   *  Constant: '<S280>/Use Gain Schedule1'

   */

  if (LATERAL_GAIN_SCHEDULE_APV == ENUM_SWITCH_T_ON) {

    /* Lookup_n-D: '<S280>/Speed Lookup Table1' */

    L4_MABX_B.SpeedLookupTable1 = look1_binlcapw(L4_MABX_B.kmhtoms,

      L4_MABX_P.SpeedLookupTable1_bp01Data,

      L4_MABX_P.SpeedLookupTable1_tableData, 1U);

    Stanley_Set_Gain = L4_MABX_B.SpeedLookupTable1;

  } else {

    Stanley_Set_Gain = STANLEY_GAIN_APV;

  }



  /* End of MultiPortSwitch: '<S280>/Multiport Switch1' */



  /* Product: '<S280>/Product' */

  L4_MABX_B.Product_n = Stanley_Set_Gain * CrosstrackError;



  /* Sum: '<S280>/Sum' incorporates:

   *  Constant: '<S280>/Stanley Gain Ksoft'

   */

  L4_MABX_B.Sum_d = STANLEY_GAIN_KSOFT_APV + L4_MABX_B.kmhtoms;



  /* Trigonometry: '<S280>/Trigonometric Function' */

  L4_MABX_B.TrigonometricFunction_l = rt_atan2d_snf(L4_MABX_B.Product_n,

    L4_MABX_B.Sum_d);



  /* Sum: '<S280>/Sum4' incorporates:

   *  Constant: '<S280>/YAW_RATE_OFFSET_APV'

   */

  L4_MABX_B.Sum4_h = YawRate + YAW_RATE_OFFSET_APV;



  /* Product: '<S280>/Product3' */

  L4_MABX_B.Product3 = Curvature * L4_MABX_B.kmhtoms;



  /* Sum: '<S280>/Sum2' */

  L4_MABX_B.Sum2_h = L4_MABX_B.Sum4_h - L4_MABX_B.Product3;



  /* Product: '<S280>/Product1' incorporates:

   *  Constant: '<S280>/Stanley Gain Kdyaw'

   */

  L4_MABX_B.Product1_iy = STANLEY_GAIN_KDYAW_APV * L4_MABX_B.Sum2_h;



  /* Sum: '<S280>/Subtract' incorporates:

   *  Constant: '<S280>/ReAX Offset'

   */

  L4_MABX_B.Subtract_e = ReAX_ActualHandwheelPos - REAX_OFFSET_APV;



  /* Lookup_n-D: '<S280>/1-D Lookup Table' */

  L4_MABX_B.uDLookupTable_h = look1_binlxpw(L4_MABX_B.Subtract_e,

    L4_MABX_P.uDLookupTable_bp01Data_kh, L4_MABX_P.uDLookupTable_tableData_k,

    71U);



  /* Gain: '<S280>/deg2rad' */

  L4_MABX_B.deg2rad_o = L4_MABX_P.deg2rad_Gain_n * L4_MABX_B.uDLookupTable_h;



  /* Gain: '<S280>/invert' */

  L4_MABX_B.invert_d = L4_MABX_P.invert_Gain_a * L4_MABX_B.deg2rad_o;



  /* Product: '<S280>/Multiply' */

  L4_MABX_B.Multiply_a = L4_MABX_B.invert_d * L4_MABX_B.Sum4_h;



  /* Gain: '<S280>/Gain' */

  L4_MABX_B.Gain_gm = L4_MABX_P.Gain_Gain_k * L4_MABX_B.Multiply_a;



  /* Sum: '<S280>/Sum3' */

  L4_MABX_B.Sum3_j = L4_MABX_B.invert_d - L4_MABX_B.Gain_gm;



  /* Product: '<S280>/Product2' incorporates:

   *  Constant: '<S280>/Stanley Gain Kdsteer'

   */

  L4_MABX_B.Product2_p = STANLEY_GAIN_KDSTEER_APV * L4_MABX_B.Sum3_j;



  /* Gain: '<S280>/Gain2' */

  L4_MABX_B.Gain2_l = L4_MABX_P.Gain2_Gain_c * Curvature;



  /* MultiPortSwitch: '<S280>/Multiport Switch2' incorporates:

   *  Constant: '<S280>/Understeer Corection'

   *  Constant: '<S280>/Use Gain Schedule'

   */

  if (LATERAL_GAIN_SCHEDULE_APV == ENUM_SWITCH_T_ON) {

    /* Lookup_n-D: '<S280>/Speed Lookup Table' */

    L4_MABX_B.SpeedLookupTable_a = look1_binlcapw(L4_MABX_B.kmhtoms,

      L4_MABX_P.SpeedLookupTable_bp01Data, L4_MABX_P.SpeedLookupTable_tableData,

      1U);

    Understeer_Correction_Output = L4_MABX_B.SpeedLookupTable_a;

  } else {

    Understeer_Correction_Output = UndersteerCorection;

  }



  /* End of MultiPortSwitch: '<S280>/Multiport Switch2' */



  /* Product: '<S280>/Multiply1' */

  L4_MABX_B.Multiply1 = L4_MABX_B.Gain2_l * Understeer_Correction_Output;



  /* Sum: '<S280>/Sum1' */

  Stanley_Output = (((L4_MABX_B.Lateral_Control_Heading_Error_k +

                      L4_MABX_B.TrigonometricFunction_l) + L4_MABX_B.Product1_iy)

                    + L4_MABX_B.Product2_p) + L4_MABX_B.Multiply1;



  /* UnitDelay: '<S304>/Delay Input2' */

  L4_MABX_B.Yk1_b = L4_MABX_DW.DelayInput2_DSTATE_o;



  /* Sum: '<S304>/Difference Inputs1' */

  L4_MABX_B.UkYk1_n2 = Stanley_Output - L4_MABX_B.Yk1_b;



  /* RelationalOperator: '<S306>/LowerRelop1' */

  L4_MABX_B.LowerRelop1_g = (L4_MABX_B.UkYk1_n2 > L4_MABX_B.deltariselimit_cn);



  /* Gain: '<S301>/Gain3' */

  L4_MABX_B.RateLimitLower_d = L4_MABX_P.Gain3_Gain_n * Stanley_Rate_Limit;



  /* Product: '<S304>/delta fall limit' */

  L4_MABX_B.deltafalllimit_g = L4_MABX_B.RateLimitLower_d *

    L4_MABX_B.sampletime_ca;



  /* RelationalOperator: '<S306>/UpperRelop' */

  L4_MABX_B.UpperRelop_a = (L4_MABX_B.UkYk1_n2 < L4_MABX_B.deltafalllimit_g);



  /* Switch: '<S306>/Switch' */

  if (L4_MABX_B.UpperRelop_a) {

    L4_MABX_B.Switch_pt = L4_MABX_B.deltafalllimit_g;

  } else {

    L4_MABX_B.Switch_pt = L4_MABX_B.UkYk1_n2;

  }



  /* End of Switch: '<S306>/Switch' */



  /* Switch: '<S306>/Switch2' */

  if (L4_MABX_B.LowerRelop1_g) {

    L4_MABX_B.Switch2_n = L4_MABX_B.deltariselimit_cn;

  } else {

    L4_MABX_B.Switch2_n = L4_MABX_B.Switch_pt;

  }



  /* End of Switch: '<S306>/Switch2' */



  /* Sum: '<S304>/Difference Inputs2' */

  L4_MABX_B.DifferenceInputs2_f = L4_MABX_B.Switch2_n + L4_MABX_B.Yk1_b;



  /* RelationalOperator: '<S305>/LowerRelop1' */

  L4_MABX_B.LowerRelop1_o1 = (L4_MABX_B.DifferenceInputs2_f >

    L4_MABX_B.SaturationSpeedLookup_d);



  /* Gain: '<S301>/Gain1' */

  L4_MABX_B.Gain1_i = L4_MABX_P.Gain1_Gain_f * L4_MABX_B.SaturationSpeedLookup_d;



  /* RelationalOperator: '<S305>/UpperRelop' */

  L4_MABX_B.UpperRelop_p = (L4_MABX_B.DifferenceInputs2_f < L4_MABX_B.Gain1_i);



  /* Switch: '<S305>/Switch' */

  if (L4_MABX_B.UpperRelop_p) {

    L4_MABX_B.Switch_i1 = L4_MABX_B.Gain1_i;

  } else {

    L4_MABX_B.Switch_i1 = L4_MABX_B.DifferenceInputs2_f;

  }



  /* End of Switch: '<S305>/Switch' */



  /* Switch: '<S305>/Switch2' */

  if (L4_MABX_B.LowerRelop1_o1) {

    L4_MABX_B.Switch2_g = L4_MABX_B.SaturationSpeedLookup_d;

  } else {

    L4_MABX_B.Switch2_g = L4_MABX_B.Switch_i1;

  }



  /* End of Switch: '<S305>/Switch2' */



  /* Outputs for Atomic SubSystem: '<S301>/If_Then_Else' */

  L4_MABX_If_Then_Else_k(L4_MABX_B.DataTypeConversion_g, L4_MABX_B.Switch2_g,

    Stanley_Output, &L4_MABX_B.If_Then_Else_kz);



  /* End of Outputs for SubSystem: '<S301>/If_Then_Else' */



  /* SignalConversion: '<S301>/TmpSignal ConversionAtIf_Then_ElseOutport1' */

  Stanley_Rate_Limiter_Output = L4_MABX_B.If_Then_Else_kz.Switch;



  /* Outputs for Atomic SubSystem: '<S280>/If_Then_Else' */

  L4_MABX_If_Then_Else_g(L4_MABX_B.AutonomousEnabled_d,

    Stanley_Rate_Limiter_Output, L4_MABX_B.invert_d, &L4_MABX_B.If_Then_Else_n);



  /* End of Outputs for SubSystem: '<S280>/If_Then_Else' */



  /* MultiPortSwitch: '<S80>/Multiport Switch2' incorporates:

   *  Constant: '<S80>/LAT_STEER_SRC_SELECTOR_APV'

   */

  switch (LAT_STEER_SRC_SELECTOR_APV) {

   case ENUM_LAT_STEER_SOURCE_T_PIC_HARIS:

    L4_MABX_B.MultiportSwitch2_b = L4_MABX_B.If_Then_Else_m.Switch;

    break;



   case ENUM_LAT_STEER_SOURCE_T_PIC_STANLEY:

    L4_MABX_B.MultiportSwitch2_b = L4_MABX_B.If_Then_Else_n.Switch;

    break;



   default:

    /* Switch: '<S80>/Switch' */

    if (TargetVelocity_kph > L4_MABX_P.Switch_Threshold) {

      L4_MABX_B.Switch_ph = L4_MABX_B.If_Then_Else_m.Switch;

    } else {

      L4_MABX_B.Switch_ph = L4_MABX_B.If_Then_Else_n.Switch;

    }



    /* End of Switch: '<S80>/Switch' */

    L4_MABX_B.MultiportSwitch2_b = L4_MABX_B.Switch_ph;

    break;

  }



  /* End of MultiPortSwitch: '<S80>/Multiport Switch2' */



  /* DataTypeConversion: '<S80>/Data Type Conversion6' */

  L4_MABX_B.DataTypeConversion6_pa = L4_MABX_B.MultiportSwitch2_b;



  /* Gain: '<S80>/rad2deg' */

  L4_MABX_B.rad2deg = L4_MABX_P.rad2deg_Gain * L4_MABX_B.DataTypeConversion6_pa;



  /* Gain: '<S80>/sign flip' */

  SteerCommandDeg = L4_MABX_P.signflip_Gain * L4_MABX_B.rad2deg;



  /* MultiPortSwitch: '<S80>/Multiport Switch1' incorporates:

   *  Constant: '<S80>/LONG_SPEED_SRC_SELECTOR_APV'

   *  Constant: '<S80>/SteeringOverrideVal1'

   */

  switch (LONG_SPEED_SRC_SELECTOR_APV) {

   case ENUM_LONG_SPEED_DEMAND_SOURCE_T_GPS_PATH:

    /* MultiPortSwitch: '<S80>/Multiport Switch' incorporates:

     *  Constant: '<S80>/SteeringControlSRC'

     *  Constant: '<S80>/SteeringOverrideVal'

     */

    switch (L4_MABX_P.SteeringControlSRC_Value) {

     case 0:

      L4_MABX_B.MultiportSwitch_f = L4_MABX_P.SteeringOverrideVal_Value;

      break;



     case 1:

      L4_MABX_B.MultiportSwitch_f = L4_MABX_B.Switch2_i;

      break;



     case 2:

      /* DataTypeConversion: '<S80>/Data Type Conversion2' */

      L4_MABX_B.DataTypeConversion2_o = L4_MABX_B.Add2;

      L4_MABX_B.MultiportSwitch_f = L4_MABX_B.DataTypeConversion2_o;

      break;



     default:

      /* DataTypeConversion: '<S80>/Data Type Conversion3' */

      L4_MABX_B.DataTypeConversion3_p = L4_MABX_B.Add1_hl;

      L4_MABX_B.MultiportSwitch_f = L4_MABX_B.DataTypeConversion3_p;

      break;

    }



    /* End of MultiPortSwitch: '<S80>/Multiport Switch' */



    /* Gain: '<S80>/rad2deg2' */

    L4_MABX_B.rad2deg2 = L4_MABX_P.rad2deg2_Gain * L4_MABX_B.MultiportSwitch_f;

    L4_MABX_B.MultiportSwitch1 = L4_MABX_B.rad2deg2;

    break;



   case ENUM_LONG_SPEED_DEMAND_SOURCE_T_OVERRIDE:

    L4_MABX_B.MultiportSwitch1 = L4_MABX_P.SteeringOverrideVal1_Value;

    break;



   default:

    L4_MABX_B.MultiportSwitch1 = SteerCommandDeg;

    break;

  }



  /* End of MultiPortSwitch: '<S80>/Multiport Switch1' */



  /* Lookup_n-D: '<S276>/1D_Lookup_Table' */

  L4_MABX_B.uD_Lookup_Table_a = look1_binlcapw(L4_MABX_B.MultiportSwitch1,

    STEERCTRL_WHEEL_ANGLE_STEP_MPV, STEERCTRL_WHEEL_ANGLE_DATA_MPV, 71U);



  /* DataTypeConversion: '<S80>/Data Type Conversion4' */

  L4_MABX_B.numLanePoints_j = L4_MABX_B.DataTypeConversion5_e3;



  /* DiscreteIntegrator: '<S80>/Discrete-Time Integrator' incorporates:

   *  Constant: '<S80>/ResetIntegrator'

   */

  if ((L4_MABX_P.ResetIntegrator_Value != 0.0) ||

      (L4_MABX_DW.DiscreteTimeIntegrator_PrevRe_e != 0)) {

    L4_MABX_DW.DiscreteTimeIntegrator_DSTATE_e =

      L4_MABX_P.DiscreteTimeIntegrator_IC;

  }



  if (L4_MABX_DW.DiscreteTimeIntegrator_DSTATE_e >=

      L4_MABX_P.DiscreteTimeIntegrator_UpperSat) {

    L4_MABX_DW.DiscreteTimeIntegrator_DSTATE_e =

      L4_MABX_P.DiscreteTimeIntegrator_UpperSat;

  } else {

    if (L4_MABX_DW.DiscreteTimeIntegrator_DSTATE_e <=

        L4_MABX_P.DiscreteTimeIntegrator_LowerSat) {

      L4_MABX_DW.DiscreteTimeIntegrator_DSTATE_e =

        L4_MABX_P.DiscreteTimeIntegrator_LowerSat;

    }

  }



  L4_MABX_B.DiscreteTimeIntegrator_h =

    L4_MABX_DW.DiscreteTimeIntegrator_DSTATE_e;



  /* End of DiscreteIntegrator: '<S80>/Discrete-Time Integrator' */



  /* RelationalOperator: '<S288>/Lower Test' incorporates:

   *  Constant: '<S288>/Lower Limit'

   */

  L4_MABX_B.LowerTest = (L4_MABX_P.IntervalTest_lowlimit <= L4_MABX_B.Divide_nn);



  /* RelationalOperator: '<S288>/Upper Test' incorporates:

   *  Constant: '<S288>/Upper Limit'

   */

  L4_MABX_B.UpperTest = (L4_MABX_B.Divide_nn <= L4_MABX_P.IntervalTest_uplimit);



  /* Logic: '<S288>/AND' */

  L4_MABX_B.AND_p = (L4_MABX_B.LowerTest && L4_MABX_B.UpperTest);



  /* Assertion: '<S285>/Assertion' */

  utAssert(L4_MABX_B.AND_p);



  /* RelationalOperator: '<S293>/Lower Test' incorporates:

   *  Constant: '<S293>/Lower Limit'

   */

  L4_MABX_B.LowerTest_l = (L4_MABX_P.IntervalTest_lowlimit_k <=

    L4_MABX_B.Divide_d0);



  /* RelationalOperator: '<S293>/Upper Test' incorporates:

   *  Constant: '<S293>/Upper Limit'

   */

  L4_MABX_B.UpperTest_e = (L4_MABX_B.Divide_d0 <=

    L4_MABX_P.IntervalTest_uplimit_e);



  /* Logic: '<S293>/AND' */

  L4_MABX_B.AND_jt = (L4_MABX_B.LowerTest_l && L4_MABX_B.UpperTest_e);



  /* Assertion: '<S290>/Assertion' */

  utAssert(L4_MABX_B.AND_jt);



  /* Switch: '<S296>/Switch' incorporates:

   *  Constant: '<S279>/Constant8'

   *  Constant: '<S279>/Constant9'

   */

  if (L4_MABX_P.Constant8_Value_l) {

    L4_MABX_B.Switch_k = L4_MABX_P.Constant9_Value;

  } else {

    L4_MABX_B.Switch_k = L4_MABX_B.Add_px;

  }



  /* End of Switch: '<S296>/Switch' */



  /* RelationalOperator: '<S80>/Relational Operator' incorporates:

   *  Constant: '<S80>/Constant1'

   */

  L4_MABX_B.RelationalOperator_oq = (L4_MABX_B.DataTypeConversion5_e3 >=

    L4_MABX_P.Constant1_Value_ls);



  /* Sum: '<S301>/Subtract' */

  L4_MABX_B.Subtract_gn = Stanley_Output - L4_MABX_B.DifferenceInputs2_f;



  /* Abs: '<S301>/Abs2' */

  L4_MABX_B.Abs2_i = fabs(L4_MABX_B.Subtract_gn);



  /* RelationalOperator: '<S302>/Compare' incorporates:

   *  Constant: '<S302>/Constant'

   */

  Stanley_Limiter_Active = (L4_MABX_B.Abs2_i >

    L4_MABX_P.CompareToConstant_const_f);



  /* Abs: '<S301>/Abs1' */

  L4_MABX_B.Abs1_p = fabs(L4_MABX_B.Lateral_Control_Heading_Error_k);



  /* Lookup_n-D: '<S301>/Error Lookup Table' */

  L4_MABX_B.RateError = look1_binlcapw(L4_MABX_B.Abs1_p,

    L4_MABX_P.ErrorLookupTable_bp01Data, L4_MABX_P.ErrorLookupTable_tableData,

    4U);



  /* RateLimiter: '<S301>/Limit Rate Limiter' */

  PositionFinalLimited = L4_MABX_B.RateError - L4_MABX_DW.PrevY;

  if (PositionFinalLimited > L4_MABX_P.LimitRateLimiter_RisingLim) {

    L4_MABX_B.LimitRateLimiter = L4_MABX_DW.PrevY +

      L4_MABX_P.LimitRateLimiter_RisingLim;

  } else if (PositionFinalLimited < L4_MABX_P.LimitRateLimiter_FallingLim) {

    L4_MABX_B.LimitRateLimiter = L4_MABX_DW.PrevY +

      L4_MABX_P.LimitRateLimiter_FallingLim;

  } else {

    L4_MABX_B.LimitRateLimiter = L4_MABX_B.RateError;

  }



  L4_MABX_DW.PrevY = L4_MABX_B.LimitRateLimiter;



  /* End of RateLimiter: '<S301>/Limit Rate Limiter' */



  /* Gain: '<S307>/Gain' */

  L4_MABX_B.Gain_o = L4_MABX_P.Gain_Gain_p * L4_MABX_B.DiscreteTimeIntegrator;



  /* Gain: '<S313>/Integral Gain' */

  L4_MABX_B.IntegralGain = Lateral_Control_I * L4_MABX_B.If_Then_Else1_m.Switch;



  /* Abs: '<S316>/Abs' */

  L4_MABX_B.Abs_ig = fabs(L4_MABX_B.If_Then_Else_pe.Switch);



  /* Abs: '<S316>/Abs1' */

  L4_MABX_B.Abs1_ft = fabs(L4_MABX_B.DifferenceInputs2);



  /* Sum: '<S316>/Subtract' */

  L4_MABX_B.Subtract_o = Lateral_Control_Output - L4_MABX_B.DifferenceInputs2_m;



  /* Abs: '<S316>/Abs2' */

  L4_MABX_B.Abs2_k = fabs(L4_MABX_B.Subtract_o);



  /* RelationalOperator: '<S325>/Compare' incorporates:

   *  Constant: '<S325>/Constant'

   */

  RateLimiterActive = (L4_MABX_B.Abs2_k > L4_MABX_P.CompareToConstant_const_g);



  /* Lookup_n-D: '<S316>/Curvature Lookup Table' */

  L4_MABX_B.RateCurvature = look1_binlcapw(L4_MABX_B.Abs_ig,

    L4_MABX_P.CurvatureLookupTable_bp01Data,

    L4_MABX_P.CurvatureLookupTable_tableData, 4U);



  /* Lookup_n-D: '<S316>/Error Lookup Table' */

  L4_MABX_B.RateError_o = look1_binlcapw(L4_MABX_B.Abs1_ft,

    L4_MABX_P.ErrorLookupTable_bp01Data_j,

    L4_MABX_P.ErrorLookupTable_tableData_e, 4U);



  /* MinMax: '<S316>/Max' */

  DeltaTime = L4_MABX_B.RateCurvature;

  PositionFinalLimited = L4_MABX_B.RateError_o;

  if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.Max = PositionFinalLimited;



  /* End of MinMax: '<S316>/Max' */



  /* Lookup_n-D: '<S316>/Speed Lookup Table' */

  L4_MABX_B.RateSpeed = look1_binlcapw(L4_MABX_B.DataTypeConversion_k,

    L4_MABX_P.SpeedLookupTable_bp01Data_a,

    L4_MABX_P.SpeedLookupTable_tableData_co, 5U);



  /* MinMax: '<S316>/Min' */

  DeltaTime = L4_MABX_B.Max;

  PositionFinalLimited = L4_MABX_B.RateSpeed;

  if ((DeltaTime < PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.Min = PositionFinalLimited;



  /* End of MinMax: '<S316>/Min' */



  /* RateLimiter: '<S316>/Limit Rate Limiter' */

  PositionFinalLimited = L4_MABX_B.Min - L4_MABX_DW.PrevY_o;

  if (PositionFinalLimited > L4_MABX_P.LimitRateLimiter_RisingLim_d) {

    L4_MABX_B.RateLimitUpper = L4_MABX_DW.PrevY_o +

      L4_MABX_P.LimitRateLimiter_RisingLim_d;

  } else if (PositionFinalLimited < L4_MABX_P.LimitRateLimiter_FallingLim_j) {

    L4_MABX_B.RateLimitUpper = L4_MABX_DW.PrevY_o +

      L4_MABX_P.LimitRateLimiter_FallingLim_j;

  } else {

    L4_MABX_B.RateLimitUpper = L4_MABX_B.Min;

  }



  L4_MABX_DW.PrevY_o = L4_MABX_B.RateLimitUpper;



  /* End of RateLimiter: '<S316>/Limit Rate Limiter' */



  /* Gain: '<S80>/sign2' */

  DesiredSteeringAngle = L4_MABX_P.sign2_Gain * L4_MABX_B.uD_Lookup_Table_a;



  /* Sum: '<S80>/Subtract' incorporates:

   *  Constant: '<S80>/Constant'

   */

  L4_MABX_B.Subtract_c1 = DesiredSteeringAngle + REAX_OFFSET_APV;



  /* UnitDelay: '<S80>/Unit Delay' */

  L4_MABX_B.UnitDelay_p = L4_MABX_DW.UnitDelay_DSTATE_e;



  /* Switch: '<S80>/Switch1' incorporates:

   *  Constant: '<S80>/Constant2'

   *  Switch: '<S80>/Switch2'

   */

  if (L4_MABX_B.RelationalOperator_oq) {

    /* Product: '<S80>/Product3' incorporates:

     *  Constant: '<S80>/SteeringControlNewIGain1'

     */

    L4_MABX_B.Product3_b = L4_MABX_B.mm2m *

      L4_MABX_P.SteeringControlNewIGain1_Value;

    L4_MABX_B.Switch1_p = L4_MABX_B.Product3_b;



    /* Gain: '<S80>/deg2rad' */

    L4_MABX_B.deg2rad_d = L4_MABX_P.deg2rad_Gain * L4_MABX_B.SFunction1_o1_oq;



    /* Product: '<S80>/Product2' incorporates:

     *  Constant: '<S80>/SteeringControlNewPGain1'

     */

    L4_MABX_B.Product2_my = L4_MABX_B.deg2rad_d *

      L4_MABX_P.SteeringControlNewPGain1_Value;

    L4_MABX_B.Switch2_i1 = L4_MABX_B.Product2_my;

  } else {

    L4_MABX_B.Switch1_p = L4_MABX_P.Constant2_Value_n;

    L4_MABX_B.Switch2_i1 = L4_MABX_B.UnitDelay_p;

  }



  /* End of Switch: '<S80>/Switch1' */



  /* RelationalOperator: '<S359>/min_relop' incorporates:

   *  Constant: '<S359>/min_val'

   */

  L4_MABX_B.min_relop_k = (L4_MABX_P.CheckStaticLowerBound_min_o <=

    L4_MABX_B.Divide_e);



  /* Assertion: '<S359>/Assertion' */

  utAssert(L4_MABX_B.min_relop_k);



  /* Logic: '<S368>/Logical Operator2' */

  L4_MABX_B.LogicalOperator2_g = !L4_MABX_B.LogicalOperator1_ph;



  /* Switch: '<S377>/Reset' incorporates:

   *  Constant: '<S372>/CPV'

   */

  if (L4_MABX_B.LogicalOperator1_ja) {

    L4_MABX_B.Xnew = L4_MABX_P.CPV_Value_h;

  } else {

    L4_MABX_B.Xnew = L4_MABX_B.If_Then_Else_gf.Switch;

  }



  /* End of Switch: '<S377>/Reset' */



  /* UnitDelay: '<S379>/FixPt Unit Delay2' */

  L4_MABX_B.FixPtUnitDelay2_j = L4_MABX_DW.FixPtUnitDelay2_DSTATE_aw;



  /* Logic: '<S379>/FixPt Logical Operator' */

  L4_MABX_B.FixPtLogicalOperator_i = (uint8_T)(L4_MABX_B.LogicalOperator1_ja ||

    (L4_MABX_B.FixPtUnitDelay2_j != 0));



  /* UnitDelay: '<S379>/FixPt Unit Delay1' */

  L4_MABX_B.Xold_dp = L4_MABX_DW.FixPtUnitDelay1_DSTATE_p;



  /* Switch: '<S379>/Init' incorporates:

   *  Constant: '<S373>/CPV'

   */

  if (L4_MABX_B.FixPtLogicalOperator_i != 0) {

    L4_MABX_B.Init_o = L4_MABX_P.CPV_Value_n;

  } else {

    L4_MABX_B.Init_o = L4_MABX_B.Xold_dp;

  }



  /* End of Switch: '<S379>/Init' */



  /* UnitDelay: '<S380>/FixPt Unit Delay2' */

  L4_MABX_B.FixPtUnitDelay2_m = L4_MABX_DW.FixPtUnitDelay2_DSTATE_gx;



  /* Logic: '<S380>/FixPt Logical Operator' */

  L4_MABX_B.FixPtLogicalOperator_b = (uint8_T)(L4_MABX_B.LogicalOperator1_ja ||

    (L4_MABX_B.FixPtUnitDelay2_m != 0));



  /* UnitDelay: '<S380>/FixPt Unit Delay1' */

  L4_MABX_B.Xold_m = L4_MABX_DW.FixPtUnitDelay1_DSTATE_g0;



  /* Switch: '<S380>/Init' incorporates:

   *  Constant: '<S371>/CPV2'

   */

  if (L4_MABX_B.FixPtLogicalOperator_b != 0) {

    L4_MABX_B.Init_l = L4_MABX_P.CPV2_Value_p;

  } else {

    L4_MABX_B.Init_l = L4_MABX_B.Xold_m;

  }



  /* End of Switch: '<S380>/Init' */



  /* MultiPortSwitch: '<S378>/Multiport Switch' incorporates:

   *  Constant: '<S371>/CPV2'

   *  Constant: '<S378>/Integrator_method'

   */

  switch ((int32_T)L4_MABX_P.Integrator_method_Value) {

   case 1:

    L4_MABX_B.MultiportSwitch_i = L4_MABX_P.CPV2_Value_p;

    break;



   case 2:

    L4_MABX_B.MultiportSwitch_i = L4_MABX_B.Init_l;

    break;



   default:

    /* Sum: '<S378>/Add' incorporates:

     *  Constant: '<S371>/CPV2'

     */

    L4_MABX_B.Add_py = L4_MABX_B.Init_l + L4_MABX_P.CPV2_Value_p;



    /* Gain: '<S378>/Gain' */

    L4_MABX_B.u_trapezoidal = L4_MABX_P.Gain_Gain_j * L4_MABX_B.Add_py;

    L4_MABX_B.MultiportSwitch_i = L4_MABX_B.u_trapezoidal;

    break;

  }



  /* End of MultiPortSwitch: '<S378>/Multiport Switch' */



  /* DigitalClock: '<S374>/Digital Clock' */

  L4_MABX_B.DigitalClock_d = L4_MABX_M->Timing.t[0];



  /* UnitDelay: '<S374>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_p = L4_MABX_DW.Unit_Delay_DSTATE_j;



  /* Sum: '<S374>/Subtract' */

  L4_MABX_B.Subtract_k = L4_MABX_B.DigitalClock_d - L4_MABX_B.Unit_Delay_p;



  /* Product: '<S373>/Product1' incorporates:

   *  Constant: '<S371>/CPV'

   */

  L4_MABX_B.Product1_am = L4_MABX_P.CPV_Value_g * L4_MABX_B.MultiportSwitch_i *

    L4_MABX_B.Subtract_k;



  /* Sum: '<S373>/Add' */

  L4_MABX_B.Add_db = L4_MABX_B.Init_o + L4_MABX_B.Product1_am;



  /* Switch: '<S380>/Reset' incorporates:

   *  Constant: '<S371>/CPV2'

   */

  L4_MABX_B.Xnew_f = L4_MABX_P.CPV2_Value_p;



  /* Switch: '<S379>/Reset' incorporates:

   *  Constant: '<S373>/CPV'

   */

  if (L4_MABX_B.LogicalOperator1_ja) {

    L4_MABX_B.Xnew_h = L4_MABX_P.CPV_Value_n;

  } else {

    L4_MABX_B.Xnew_h = L4_MABX_B.Add_db;

  }



  /* End of Switch: '<S379>/Reset' */



  /* RelationalOperator: '<S387>/min_relop' incorporates:

   *  Constant: '<S351>/FCW_CTRL_SLEW_INC_APV'

   *  Constant: '<S387>/min_val'

   */

  L4_MABX_B.min_relop_cb = (L4_MABX_P.CheckStaticLowerBound_min_h <=

    L4_MABX_P.FCW_CTRL_SLEW_INC_APV_Value);



  /* Assertion: '<S387>/Assertion' */

  utAssert(L4_MABX_B.min_relop_cb);



  /* RelationalOperator: '<S398>/min_relop' incorporates:

   *  Constant: '<S353>/STABILITY_CTRL_SLEW_INC_APV'

   *  Constant: '<S398>/min_val'

   */

  L4_MABX_B.min_relop_f = (L4_MABX_P.CheckStaticLowerBound_min_nz <=

    L4_MABX_P.STABILITY_CTRL_SLEW_INC_APV_Val);



  /* Assertion: '<S398>/Assertion' */

  utAssert(L4_MABX_B.min_relop_f);



  /* End of Outputs for SubSystem: '<S65>/Task_10ms' */



  /* Outputs for Enabled SubSystem: '<S631>/PosRapidUpdate_011' incorporates:

   *  EnablePort: '<S632>/Enable'

   */

  /* Constant: '<S454>/Constant' */

  if (L4_MABX_P.Constant_Value_ba > 0.0) {

    /* S-Function (rti_commonblock): '<S632>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "PosRapidUpdate_01" Id:167248128 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80100].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80100].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o3_bt = 1.0;

        L4_MABX_B.SFunction1_o4_ez = (real_T)

          can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80100].timestamp;

        L4_MABX_B.SFunction1_o5_gx = (real_T)

          can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80100].deltatime;

        CAN_Msg = can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80100].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "Latitude_" (0|32, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[1];

            CAN_Sgn.SgnBytes.Byte2 = CAN_Msg[2];

            CAN_Sgn.SgnBytes.Byte3 = CAN_Msg[3];

            L4_MABX_B.SFunction1_o1_bh = 1.0E-7 * ( ((real_T) CAN_Sgn.SignedSgn)

              );



            /* ...... "Longitude_" (32|32, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

            CAN_Sgn.SgnBytes.Byte2 = CAN_Msg[6];

            CAN_Sgn.SgnBytes.Byte3 = CAN_Msg[7];

            L4_MABX_B.SFunction1_o2_db = 1.0E-7 * ( ((real_T) CAN_Sgn.SignedSgn)

              );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o3_bt = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S631>/PosRapidUpdate_011' */



  /* Outputs for Atomic SubSystem: '<S472>/If_Then_Else' */



  /* Constant: '<S472>/useGPSSA00' incorporates:

   *  Constant: '<S472>/useGPSSA0'

   */

  L4_MABX_If_Then_Else3(L4_MABX_B.LogicalOperator1_c, L4_MABX_P.useGPSSA00_Value,

                        L4_MABX_P.useGPSSA0_Value, &L4_MABX_B.If_Then_Else);



  /* End of Outputs for SubSystem: '<S472>/If_Then_Else' */



  /* Outputs for Enabled SubSystem: '<S631>/PosRapidUpdate_1' incorporates:

   *  EnablePort: '<S633>/Enable'

   */

  /* Constant: '<S454>/Constant' */

  if (L4_MABX_P.Constant_Value_ba > 0.0) {

    /* S-Function (rti_commonblock): '<S633>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "PosRapidUpdate_01" Id:167248129 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80101].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80101].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o3_a = 1.0;

        L4_MABX_B.SFunction1_o4_ex = (real_T)

          can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80101].timestamp;

        L4_MABX_B.SFunction1_o5_nb = (real_T)

          can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80101].deltatime;

        CAN_Msg = can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80101].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "Latitude_" (0|32, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[1];

            CAN_Sgn.SgnBytes.Byte2 = CAN_Msg[2];

            CAN_Sgn.SgnBytes.Byte3 = CAN_Msg[3];

            L4_MABX_B.SFunction1_o1_ju = 1.0E-7 * ( ((real_T) CAN_Sgn.SignedSgn)

              );



            /* ...... "Longitude_" (32|32, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

            CAN_Sgn.SgnBytes.Byte2 = CAN_Msg[6];

            CAN_Sgn.SgnBytes.Byte3 = CAN_Msg[7];

            L4_MABX_B.SFunction1_o2_aq = 1.0E-7 * ( ((real_T) CAN_Sgn.SignedSgn)

              );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o3_a = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S631>/PosRapidUpdate_1' */



  /* Switch: '<S631>/Switch' */

  if (L4_MABX_B.If_Then_Else.Switch) {

    L4_MABX_B.Latitude_ = L4_MABX_B.SFunction1_o1_bh;

    L4_MABX_B.Longitude_ = L4_MABX_B.SFunction1_o2_db;

  } else {

    L4_MABX_B.Latitude_ = L4_MABX_B.SFunction1_o1_ju;

    L4_MABX_B.Longitude_ = L4_MABX_B.SFunction1_o2_aq;

  }



  /* Outputs for Enabled SubSystem: '<S511>/CCVS1_00' incorporates:

   *  EnablePort: '<S512>/Enable'

   */

  /* Constant: '<S435>/Constant' */

  if (L4_MABX_P.Constant_Value_d2) {

    /* S-Function (rti_commonblock): '<S512>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "CCVS1_00" Id:218034432 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCFEF100].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCFEF100].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o21_j = 1.0;

        L4_MABX_B.SFunction1_o22_oy = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCFEF100].timestamp;

        L4_MABX_B.SFunction1_o23_o = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCFEF100].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCFEF100].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "TwoSpeedAxleSwitch" (0|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o1_g3 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ParkingBrakeSwitch" (2|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o2_g4 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "CruiseCtrlPauseSwitch" (4|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o3_ne = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ParkBrakeReleaseInhibitRq" (6|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o4_e3 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "WheelBasedVehicleSpeed" (8|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            WheelBasedVehicleSpeed = 0.00390625 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) );



            /* ...... "CruiseCtrlActive" (24|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o6_oc = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "CruiseCtrlEnableSwitch" (26|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o7_dk = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "BrakeSwitch" (28|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            BrakeSwitch = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ClutchSwitch" (30|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o9_p = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "CruiseCtrlSetSwitch" (32|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o10_or = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "CruiseCtrlCoastSwitch" (34|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o11_ae = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "CruiseCtrlResumeSwitch" (36|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o12_jy = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "CruiseCtrlAccelerateSwitch" (38|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o13_ou = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "CruiseCtrlSetSpeed" (40|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o14_b = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "PTOGovernorState" (48|5, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x0000001F;

            L4_MABX_B.SFunction1_o15_dd = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "CruiseCtrlStates" (53|3, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 5;

            CAN_Sgn.UnsignedSgn &= 0x00000007;

            L4_MABX_B.SFunction1_o16_g = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EngIdleIncrementSwitch" (56|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o17_n = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EngIdleDecrementSwitch" (58|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o18_g = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EngTestModeSwitch" (60|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o19_a = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EngShutdownOverrideSwitch" (62|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o20_ir = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o21_j = 0.0;

      }

    }

  }



  /* End of Constant: '<S435>/Constant' */

  /* End of Outputs for SubSystem: '<S511>/CCVS1_00' */



  /* Outputs for Enabled SubSystem: '<S515>/COGSOGRapidUpdate_00' incorporates:

   *  EnablePort: '<S516>/Enable'

   */

  /* Constant: '<S437>/Constant' */

  if (L4_MABX_P.Constant_Value_ky > 0.0) {

    /* S-Function (rti_commonblock): '<S516>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "COGSOGRapidUpdate_00" Id:167248384 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80200].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80200].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o5_nx = 1.0;

        L4_MABX_B.SFunction1_o6_ez = (real_T)

          can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80200].timestamp;

        L4_MABX_B.SFunction1_o7_j = (real_T)

          can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80200].deltatime;

        CAN_Msg = can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80200].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "SID" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_nq = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "COGReference" (8|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o2_co = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "CourseOverGround" (16|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o3_at = 0.0001 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) );



            /* ...... "SpeedOverGround" (32|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o4_az = 0.01 * ( ((real_T) CAN_Sgn.UnsignedSgn)

              );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o5_nx = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S515>/COGSOGRapidUpdate_00' */



  /* DataTypeConversion: '<S515>/Data Type Conversion8' */

  L4_MABX_B.RX_status_e = (L4_MABX_B.SFunction1_o5_nx != 0.0);



  /* Outputs for Enabled SubSystem: '<S515>/COGSOGRapidUpdate_1' incorporates:

   *  EnablePort: '<S517>/Enable'

   */

  /* Constant: '<S437>/Constant' */

  if (L4_MABX_P.Constant_Value_ky > 0.0) {

    /* S-Function (rti_commonblock): '<S517>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "COGSOGRapidUpdate_00" Id:167248385 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80201].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80201].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o5_f1p = 1.0;

        L4_MABX_B.SFunction1_o6_f = (real_T)

          can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80201].timestamp;

        L4_MABX_B.SFunction1_o7_bu = (real_T)

          can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80201].deltatime;

        CAN_Msg = can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x9F80201].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "SID" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_ar = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "COGReference" (8|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o2_p0 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "CourseOverGround" (16|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o3_adq = 0.0001 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) );



            /* ...... "SpeedOverGround" (32|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o4_gf = 0.01 * ( ((real_T) CAN_Sgn.UnsignedSgn)

              );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o5_f1p = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S515>/COGSOGRapidUpdate_1' */



  /* Switch: '<S515>/Switch' */

  if (L4_MABX_B.RX_status_e) {

    L4_MABX_B.SID = L4_MABX_B.SFunction1_o1_nq;

    L4_MABX_B.COGReference = L4_MABX_B.SFunction1_o2_co;

    L4_MABX_B.CourseOverGround = L4_MABX_B.SFunction1_o3_at;

    L4_MABX_B.SpeedOverGround = L4_MABX_B.SFunction1_o4_az;

  } else {

    L4_MABX_B.SID = L4_MABX_B.SFunction1_o1_ar;

    L4_MABX_B.COGReference = L4_MABX_B.SFunction1_o2_p0;

    L4_MABX_B.CourseOverGround = L4_MABX_B.SFunction1_o3_adq;

    L4_MABX_B.SpeedOverGround = L4_MABX_B.SFunction1_o4_gf;

  }



  /* Outputs for Atomic SubSystem: '<S855>/CAN_TX_100ms' */



  /* RateTransition: '<S892>/TmpRTBAtHiddenBuf_InsertedFor_Rolling_15_counter_at_inport_0Inport1' */

  if (L4_MABX_M->Timing.RateInteraction.TID0_3 == 1) {

    L4_MABX_B.TmpRTBAtHiddenBuf_InsertedFor_R = AutonomousOutputEnabled;



    /* RateTransition: '<S910>/TmpRTBAtOperatorInport1' */

    L4_MABX_B.TmpRTBAtOperatorInport1 = AutonomousOutputEnabled;



    /* RateTransition: '<S913>/TmpRTBAtOperatorInport1' */

    L4_MABX_B.TmpRTBAtOperatorInport1_c = AutonomousOutputEnabled;



    /* RateTransition: '<S904>/TmpRTBAtOperatorInport1' */

    L4_MABX_B.TmpRTBAtOperatorInport1_n = AutonomousOutputEnabled;



    /* RateTransition: '<S905>/TmpRTBAtOperatorInport1' */

    L4_MABX_B.TmpRTBAtOperatorInport1_k = AutonomousOutputEnabled;



    /* RateTransition: '<S911>/TmpRTBAtOperatorInport1' */

    L4_MABX_B.TmpRTBAtOperatorInport1_kn = AutonomousOutputEnabled;



    /* RateTransition: '<S912>/TmpRTBAtOperatorInport1' */

    L4_MABX_B.TmpRTBAtOperatorInport1_cw = AutonomousOutputEnabled;

    L4_MABX_B.Latitude__m = L4_MABX_B.Latitude_;

    L4_MABX_B.Longitude__a = L4_MABX_B.Longitude_;

    L4_MABX_B.TwoSpeedAxleSwitch_a = L4_MABX_B.SFunction1_o1_g3;

    L4_MABX_B.ParkingBrakeSwitch_m = L4_MABX_B.SFunction1_o2_g4;

    L4_MABX_B.CruiseCtrlPauseSwitch_e = L4_MABX_B.SFunction1_o3_ne;

    L4_MABX_B.ParkBrakeReleaseInhibitRq_n = L4_MABX_B.SFunction1_o4_e3;

    L4_MABX_B.WheelBasedVehicleSpeed_pj = WheelBasedVehicleSpeed;

    L4_MABX_B.CruiseCtrlActive_i = L4_MABX_B.SFunction1_o6_oc;

    L4_MABX_B.CruiseCtrlEnableSwitch_n3 = L4_MABX_B.SFunction1_o7_dk;

    L4_MABX_B.BrakeSwitch_n4 = BrakeSwitch;

    L4_MABX_B.ClutchSwitch_l = L4_MABX_B.SFunction1_o9_p;

    L4_MABX_B.CruiseCtrlSetSwitch_h = L4_MABX_B.SFunction1_o10_or;

    L4_MABX_B.CruiseCtrlCoastSwitch_c = L4_MABX_B.SFunction1_o11_ae;

    L4_MABX_B.CruiseCtrlResumeSwitch_b = L4_MABX_B.SFunction1_o12_jy;

    L4_MABX_B.CruiseCtrlAccelerateSwitch_c = L4_MABX_B.SFunction1_o13_ou;

    L4_MABX_B.CruiseCtrlSetSpeed_m = L4_MABX_B.SFunction1_o14_b;

    L4_MABX_B.PTOGovernorState_c = L4_MABX_B.SFunction1_o15_dd;

    L4_MABX_B.CruiseCtrlStates_k = L4_MABX_B.SFunction1_o16_g;

    L4_MABX_B.EngIdleIncrementSwitch_f = L4_MABX_B.SFunction1_o17_n;

    L4_MABX_B.EngIdleDecrementSwitch_i = L4_MABX_B.SFunction1_o18_g;

    L4_MABX_B.EngTestModeSwitch_d = L4_MABX_B.SFunction1_o19_a;

    L4_MABX_B.EngShutdownOverrideSwitch_p = L4_MABX_B.SFunction1_o20_ir;

    L4_MABX_B.TwoSpeedAxleSwitch_ay = L4_MABX_B.SFunction1_o1_g3;

    L4_MABX_B.ParkingBrakeSwitch_md = L4_MABX_B.SFunction1_o2_g4;

    L4_MABX_B.CruiseCtrlPauseSwitch_eq = L4_MABX_B.SFunction1_o3_ne;

    L4_MABX_B.ParkBrakeReleaseInhibitRq_n0 = L4_MABX_B.SFunction1_o4_e3;

    L4_MABX_B.WheelBasedVehicleSpeed_pjm = WheelBasedVehicleSpeed;

    L4_MABX_B.CruiseCtrlActive_iq = L4_MABX_B.SFunction1_o6_oc;

    L4_MABX_B.CruiseCtrlEnableSwitch_n3b = L4_MABX_B.SFunction1_o7_dk;

    L4_MABX_B.BrakeSwitch_n4h = BrakeSwitch;

    L4_MABX_B.ClutchSwitch_lp = L4_MABX_B.SFunction1_o9_p;

    L4_MABX_B.CruiseCtrlSetSwitch_hj = L4_MABX_B.SFunction1_o10_or;

    L4_MABX_B.CruiseCtrlCoastSwitch_cs = L4_MABX_B.SFunction1_o11_ae;

    L4_MABX_B.CruiseCtrlResumeSwitch_b4 = L4_MABX_B.SFunction1_o12_jy;

    L4_MABX_B.CruiseCtrlAccelerateSwitch_ci = L4_MABX_B.SFunction1_o13_ou;

    L4_MABX_B.CruiseCtrlSetSpeed_mm = L4_MABX_B.SFunction1_o14_b;

    L4_MABX_B.PTOGovernorState_cv = L4_MABX_B.SFunction1_o15_dd;

    L4_MABX_B.CruiseCtrlStates_ks = L4_MABX_B.SFunction1_o16_g;

    L4_MABX_B.EngIdleIncrementSwitch_f1 = L4_MABX_B.SFunction1_o17_n;

    L4_MABX_B.EngIdleDecrementSwitch_il = L4_MABX_B.SFunction1_o18_g;

    L4_MABX_B.EngTestModeSwitch_d0 = L4_MABX_B.SFunction1_o19_a;

    L4_MABX_B.EngShutdownOverrideSwitch_pi = L4_MABX_B.SFunction1_o20_ir;

    L4_MABX_B.SID_i = L4_MABX_B.SID;

    L4_MABX_B.COGReference_f = L4_MABX_B.COGReference;

    L4_MABX_B.CourseOverGround_f = L4_MABX_B.CourseOverGround;

    L4_MABX_B.SpeedOverGround_b = L4_MABX_B.SpeedOverGround;

    L4_MABX_B.ASREngCtrlActive = L4_MABX_B.SFunction1_o1_df;

    L4_MABX_B.ASRBrakeCtrlActive = L4_MABX_B.SFunction1_o2_eb;

    L4_MABX_B.AntiLockBrakingActive = L4_MABX_B.SFunction1_o3_kb;

    L4_MABX_B.EBSBrakeSwitch_j = L4_MABX_B.SFunction1_o4_nj;

    L4_MABX_B.BrakePedalPos = L4_MABX_B.SFunction1_o5_k3;

    L4_MABX_B.ABSOffroadSwitch = L4_MABX_B.SFunction1_o6_hu;

    L4_MABX_B.ASROffroadSwitch = L4_MABX_B.SFunction1_o7_k;

    L4_MABX_B.ASRHillHolderSwitch = L4_MABX_B.SFunction1_o8_lb;

    L4_MABX_B.TractionCtrlOverrideSwitch = L4_MABX_B.SFunction1_o9_oz;

    L4_MABX_B.AccelInterlockSwitch = L4_MABX_B.SFunction1_o10_dd;

    L4_MABX_B.EngDerateSwitch = L4_MABX_B.SFunction1_o11_a2;

    L4_MABX_B.EngAuxShutdownSwitch = L4_MABX_B.SFunction1_o12_c;

    L4_MABX_B.RemoteAccelEnableSwitch = L4_MABX_B.SFunction1_o13_o;

    L4_MABX_B.EngRetarderSelection = L4_MABX_B.SFunction1_o14_l;

    L4_MABX_B.ABSFullyOperational = L4_MABX_B.SFunction1_o15_a;

    L4_MABX_B.EBSRedWarningSignal = L4_MABX_B.SFunction1_o16_ed;

    L4_MABX_B.ABS_EBSAmberWarningSignal = L4_MABX_B.SFunction1_o17_d;

    L4_MABX_B.ATC_ASRInformationSignal = L4_MABX_B.SFunction1_o18_c;

    L4_MABX_B.SrcAddrssOfCtrllngDvcFrBrkCntrl = L4_MABX_B.SFunction1_o19_o;

    L4_MABX_B.HaltBrakeSwitch = L4_MABX_B.SFunction1_o20_e;

    L4_MABX_B.TrailerABSStatus = L4_MABX_B.SFunction1_o21_f;

    L4_MABX_B.TrctrMntdTrilerABSWarningSignal = L4_MABX_B.SFunction1_o22_o;

  }



  /* End of Outputs for SubSystem: '<S855>/CAN_TX_100ms' */



  /* Outputs for Atomic SubSystem: '<S855>/CAN_TX_10ms' */



  /* DataTypeConversion: '<S957>/Data Type Conversion4' */

  L4_MABX_B.DataTypeConversion4_d = L4_MABX_B.Diff;



  /* DataTypeConversion: '<S946>/Data Type Conversion' incorporates:

   *  Constant: '<S860>/CANT_ACCS_E4_CHANNEL_APV'

   */

  L4_MABX_B.DataTypeConversion_cs = (uint8_T)

    L4_MABX_P.CANT_ACCS_E4_CHANNEL_APV_Value;



  /* S-Function (sfix_bitop): '<S954>/Operator' */

  L4_MABX_B.Operator_n0 = (uint8_T)(L4_MABX_B.DataTypeConversion_cs &

    L4_MABX_P.Operator_BitMask_i5);



  /* DataTypeConversion: '<S954>/DataType' */

  L4_MABX_B.DataType_ik = L4_MABX_B.Operator_n0;



  /* ArithShift: '<S946>/Shift_Arithmetic 2' */

  L4_MABX_B.Shift_Arithmetic2_i = ldexp(L4_MABX_B.DataType_ik, (-3));



  /* DataTypeConversion: '<S946>/Data Type Conversion5' */

  L4_MABX_B.DataTypeConversion5_a = (L4_MABX_B.Shift_Arithmetic2_i != 0.0);



  /* Outputs for Enabled SubSystem: '<S957>/ACCS' incorporates:

   *  EnablePort: '<S958>/Enable'

   */

  if (L4_MABX_B.DataTypeConversion5_a) {

    /* S-Function (rti_commonblock): '<S958>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "ACCS" Id:418393572 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18F02DE4]);



      /* Convert timestamp */

      if (can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18F02DE4]->processed) {

        can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18F02DE4]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18F02DE4]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18F02DE4]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_h = (real_T)

          can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18F02DE4]->processed;

        L4_MABX_B.SFunction1_o2_j = (real_T)

          can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18F02DE4]->timestamp;

        L4_MABX_B.SFunction1_o3_br = (real_T)

          can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18F02DE4]->deltatime;

        L4_MABX_B.SFunction1_o4_d = (real_T)

          can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18F02DE4]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "LongitudinalAccelerationExRange" (16|16, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion4_d -

          ( -320 ) ) / 0.01 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte1;

      }



      /* mask unused bits with '1' */

      CAN_Msg[0] |= 0xFF;

      CAN_Msg[1] |= 0xFF;

      CAN_Msg[4] |= 0xFF;

      CAN_Msg[5] |= 0xFF;

      CAN_Msg[6] |= 0xFF;

      CAN_Msg[7] |= 0xFF;



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18F02DE4], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  /* End of Outputs for SubSystem: '<S957>/ACCS' */



  /* S-Function (sfix_bitop): '<S951>/Operator' */

  L4_MABX_B.Operator_os = (uint8_T)(L4_MABX_B.DataTypeConversion_cs &

    L4_MABX_P.Operator_BitMask_co);



  /* DataTypeConversion: '<S951>/DataType' */

  L4_MABX_B.DataType_ko = L4_MABX_B.Operator_os;



  /* S-Function (sfix_bitop): '<S952>/Operator' */

  L4_MABX_B.Operator_dt = (uint8_T)(L4_MABX_B.DataTypeConversion_cs &

    L4_MABX_P.Operator_BitMask_bi);



  /* DataTypeConversion: '<S952>/DataType' */

  L4_MABX_B.DataType_j = L4_MABX_B.Operator_dt;



  /* S-Function (sfix_bitop): '<S953>/Operator' */

  L4_MABX_B.Operator_g5 = (uint8_T)(L4_MABX_B.DataTypeConversion_cs &

    L4_MABX_P.Operator_BitMask_dt);



  /* DataTypeConversion: '<S953>/DataType' */

  L4_MABX_B.DataType_a = L4_MABX_B.Operator_g5;



  /* S-Function (sfix_bitop): '<S955>/Operator' */

  L4_MABX_B.Operator_ce = (uint8_T)(L4_MABX_B.DataTypeConversion_cs &

    L4_MABX_P.Operator_BitMask_kk);



  /* DataTypeConversion: '<S955>/DataType' */

  L4_MABX_B.DataType_d = L4_MABX_B.Operator_ce;



  /* S-Function (sfix_bitop): '<S956>/Operator' */

  L4_MABX_B.Operator_er = (uint8_T)(L4_MABX_B.DataTypeConversion_cs &

    L4_MABX_P.Operator_BitMask_od);



  /* DataTypeConversion: '<S956>/DataType' */

  L4_MABX_B.DataType_g = L4_MABX_B.Operator_er;



  /* DataTypeConversion: '<S946>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_bm = (L4_MABX_B.DataType_ko != 0);



  /* ArithShift: '<S946>/Shift_Arithmetic ' */

  L4_MABX_B.Shift_Arithmetic_m = ldexp(L4_MABX_B.DataType_j, (-1));



  /* DataTypeConversion: '<S946>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_dv = (L4_MABX_B.Shift_Arithmetic_m != 0.0);



  /* ArithShift: '<S946>/Shift_Arithmetic 1' */

  L4_MABX_B.Shift_Arithmetic1_o = ldexp(L4_MABX_B.DataType_a, (-2));



  /* DataTypeConversion: '<S946>/Data Type Conversion4' */

  L4_MABX_B.DataTypeConversion4_l1 = (L4_MABX_B.Shift_Arithmetic1_o != 0.0);



  /* ArithShift: '<S946>/Shift_Arithmetic 3' */

  L4_MABX_B.Shift_Arithmetic3_d = ldexp(L4_MABX_B.DataType_d, (-4));



  /* DataTypeConversion: '<S946>/Data Type Conversion6' */

  L4_MABX_B.DataTypeConversion6_hi = (L4_MABX_B.Shift_Arithmetic3_d != 0.0);



  /* ArithShift: '<S946>/Shift_Arithmetic 4' */

  L4_MABX_B.Shift_Arithmetic4_k = ldexp(L4_MABX_B.DataType_g, (-5));



  /* DataTypeConversion: '<S946>/Data Type Conversion7' */

  L4_MABX_B.DataTypeConversion7_ce = (L4_MABX_B.Shift_Arithmetic4_k != 0.0);



  /* DataTypeConversion: '<S965>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_me = L4_MABX_B.SFunction1_o2_dgu;



  /* DataTypeConversion: '<S965>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_d = L4_MABX_B.SFunction1_o3_ho;



  /* DataTypeConversion: '<S965>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_jg = L4_MABX_B.SFunction1_o4_ki;



  /* DataTypeConversion: '<S965>/Data Type Conversion4' */

  L4_MABX_B.DataTypeConversion4_j = L4_MABX_B.SFunction1_o1_nr;



  /* DataTypeConversion: '<S965>/Data Type Conversion5' */

  L4_MABX_B.DataTypeConversion5_l = L4_MABX_B.SFunction1_o5_nl;



  /* DataTypeConversion: '<S965>/Data Type Conversion6' */

  L4_MABX_B.DataTypeConversion6_c = L4_MABX_B.SFunction1_o6_hc;



  /* DataTypeConversion: '<S965>/Data Type Conversion7' */

  L4_MABX_B.DataTypeConversion7_e = L4_MABX_B.SFunction1_o7_ln;



  /* DataTypeConversion: '<S965>/Data Type Conversion8' */

  L4_MABX_B.DataTypeConversion8_a = L4_MABX_B.SFunction1_o8_f;



  /* DataTypeConversion: '<S947>/Data Type Conversion' incorporates:

   *  Constant: '<S860>/CANT_EEC1_00_CHANNEL_APV'

   */

  L4_MABX_B.DataTypeConversion_jn = (uint8_T)

    L4_MABX_P.CANT_EEC1_00_CHANNEL_APV_Value;



  /* S-Function (sfix_bitop): '<S962>/Operator' */

  L4_MABX_B.Operator_k1 = (uint8_T)(L4_MABX_B.DataTypeConversion_jn &

    L4_MABX_P.Operator_BitMask_cr);



  /* DataTypeConversion: '<S962>/DataType' */

  L4_MABX_B.DataType_el = L4_MABX_B.Operator_k1;



  /* ArithShift: '<S947>/Shift_Arithmetic 2' */

  L4_MABX_B.Shift_Arithmetic2_n = ldexp(L4_MABX_B.DataType_el, (-3));



  /* DataTypeConversion: '<S947>/Data Type Conversion5' */

  L4_MABX_B.DataTypeConversion5_m1 = (L4_MABX_B.Shift_Arithmetic2_n != 0.0);



  /* Outputs for Enabled SubSystem: '<S965>/EEC1_00' incorporates:

   *  EnablePort: '<S967>/Enable'

   */

  if (L4_MABX_B.DataTypeConversion5_m1) {

    /* S-Function (rti_commonblock): '<S967>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "EEC1_00" Id:217056256 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0XCF00400]);



      /* Convert timestamp */

      if (can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0XCF00400]->processed) {

        can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0XCF00400]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0XCF00400]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0XCF00400]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_kl = (real_T)

          can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0XCF00400]->processed;

        L4_MABX_B.SFunction1_o2_o = (real_T)

          can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0XCF00400]->timestamp;

        L4_MABX_B.SFunction1_o3_bv = (real_T)

          can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0XCF00400]->deltatime;

        L4_MABX_B.SFunction1_o4_e5 = (real_T)

          can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0XCF00400]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "SPN899_EngineTorqueMode" (0|4, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion4_j ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000000F;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN4154_ActEngPercTorqueFrac" (4|4, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_me - ( 0

          ) ) / 0.125 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000000F;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN512_DrvrDemEngPercTrq" (8|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (L4_MABX_B.DataTypeConversion2_d - ( -125

          ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN513_ActEngPercTorque" (16|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (L4_MABX_B.DataTypeConversion3_jg -

          ( -125 ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN190_EngineSpeed" (24|16, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion5_l - ( 0 )

          ) / 0.125 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte1;



        /* ...... "SPN1483_SAOfCtrlDevForEngineCtrl" (40|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion6_c ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN1675_EngineStarterMode" (48|4, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion7_e ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000000F;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN2432_EngDemPercTrq" (56|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (L4_MABX_B.DataTypeConversion8_a - ( -125

          ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;

      }



      /* mask unused bits with '1' */

      CAN_Msg[6] |= 0xF0;



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0XCF00400], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  /* End of Outputs for SubSystem: '<S965>/EEC1_00' */



  /* DataTypeConversion: '<S966>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_o1 = L4_MABX_B.SFunction1_o2_dgu;



  /* DataTypeConversion: '<S966>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_eq = L4_MABX_B.SFunction1_o3_ho;



  /* DataTypeConversion: '<S966>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_e = L4_MABX_B.SFunction1_o4_ki;



  /* DataTypeConversion: '<S966>/Data Type Conversion4' */

  L4_MABX_B.DataTypeConversion4_g = L4_MABX_B.SFunction1_o1_nr;



  /* DataTypeConversion: '<S966>/Data Type Conversion5' */

  L4_MABX_B.DataTypeConversion5_p = L4_MABX_B.SFunction1_o5_nl;



  /* DataTypeConversion: '<S966>/Data Type Conversion6' */

  L4_MABX_B.DataTypeConversion6_h = L4_MABX_B.SFunction1_o6_hc;



  /* DataTypeConversion: '<S966>/Data Type Conversion7' */

  L4_MABX_B.DataTypeConversion7_j = L4_MABX_B.SFunction1_o7_ln;



  /* DataTypeConversion: '<S966>/Data Type Conversion8' */

  L4_MABX_B.DataTypeConversion8_h = L4_MABX_B.SFunction1_o8_f;



  /* S-Function (sfix_bitop): '<S963>/Operator' */

  L4_MABX_B.Operator_bl = (uint8_T)(L4_MABX_B.DataTypeConversion_jn &

    L4_MABX_P.Operator_BitMask_kf);



  /* DataTypeConversion: '<S963>/DataType' */

  L4_MABX_B.DataType_ix = L4_MABX_B.Operator_bl;



  /* ArithShift: '<S947>/Shift_Arithmetic 3' */

  L4_MABX_B.Shift_Arithmetic3_e = ldexp(L4_MABX_B.DataType_ix, (-4));



  /* DataTypeConversion: '<S947>/Data Type Conversion6' */

  L4_MABX_B.DataTypeConversion6_gn = (L4_MABX_B.Shift_Arithmetic3_e != 0.0);



  /* Outputs for Enabled SubSystem: '<S966>/EEC1_00' incorporates:

   *  EnablePort: '<S968>/Enable'

   */

  if (L4_MABX_B.DataTypeConversion6_gn) {

    /* S-Function (rti_commonblock): '<S968>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "EEC1_00" Id:217056256 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0XCF00400]);



      /* Convert timestamp */

      if (can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0XCF00400]->processed) {

        can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0XCF00400]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0XCF00400]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0XCF00400]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_la = (real_T)

          can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0XCF00400]->processed;

        L4_MABX_B.SFunction1_o2_b = (real_T)

          can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0XCF00400]->timestamp;

        L4_MABX_B.SFunction1_o3_i1 = (real_T)

          can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0XCF00400]->deltatime;

        L4_MABX_B.SFunction1_o4_mk = (real_T)

          can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0XCF00400]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "SPN899_EngineTorqueMode" (0|4, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion4_g ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000000F;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN4154_ActEngPercTorqueFrac" (4|4, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_o1 - ( 0

          ) ) / 0.125 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000000F;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN512_DrvrDemEngPercTrq" (8|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (L4_MABX_B.DataTypeConversion2_eq -

          ( -125 ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN513_ActEngPercTorque" (16|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (L4_MABX_B.DataTypeConversion3_e - ( -125

          ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN190_EngineSpeed" (24|16, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion5_p - ( 0 )

          ) / 0.125 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte1;



        /* ...... "SPN1483_SAOfCtrlDevForEngineCtrl" (40|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion6_h ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN1675_EngineStarterMode" (48|4, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion7_j ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000000F;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN2432_EngDemPercTrq" (56|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (L4_MABX_B.DataTypeConversion8_h - ( -125

          ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;

      }



      /* mask unused bits with '1' */

      CAN_Msg[6] |= 0xF0;



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0XCF00400], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  /* End of Outputs for SubSystem: '<S966>/EEC1_00' */



  /* S-Function (sfix_bitop): '<S959>/Operator' */

  L4_MABX_B.Operator_ku = (uint8_T)(L4_MABX_B.DataTypeConversion_jn &

    L4_MABX_P.Operator_BitMask_am);



  /* DataTypeConversion: '<S959>/DataType' */

  L4_MABX_B.DataType_cq = L4_MABX_B.Operator_ku;



  /* S-Function (sfix_bitop): '<S960>/Operator' */

  L4_MABX_B.Operator_pu = (uint8_T)(L4_MABX_B.DataTypeConversion_jn &

    L4_MABX_P.Operator_BitMask_j);



  /* DataTypeConversion: '<S960>/DataType' */

  L4_MABX_B.DataType_e0 = L4_MABX_B.Operator_pu;



  /* S-Function (sfix_bitop): '<S961>/Operator' */

  L4_MABX_B.Operator_pn = (uint8_T)(L4_MABX_B.DataTypeConversion_jn &

    L4_MABX_P.Operator_BitMask_b3);



  /* DataTypeConversion: '<S961>/DataType' */

  L4_MABX_B.DataType_p = L4_MABX_B.Operator_pn;



  /* S-Function (sfix_bitop): '<S964>/Operator' */

  L4_MABX_B.Operator_fu = (uint8_T)(L4_MABX_B.DataTypeConversion_jn &

    L4_MABX_P.Operator_BitMask_ld);



  /* DataTypeConversion: '<S964>/DataType' */

  L4_MABX_B.DataType_o = L4_MABX_B.Operator_fu;



  /* DataTypeConversion: '<S947>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_kq = (L4_MABX_B.DataType_cq != 0);



  /* ArithShift: '<S947>/Shift_Arithmetic ' */

  L4_MABX_B.Shift_Arithmetic_f = ldexp(L4_MABX_B.DataType_e0, (-1));



  /* DataTypeConversion: '<S947>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_d5 = (L4_MABX_B.Shift_Arithmetic_f != 0.0);



  /* ArithShift: '<S947>/Shift_Arithmetic 1' */

  L4_MABX_B.Shift_Arithmetic1_g = ldexp(L4_MABX_B.DataType_p, (-2));



  /* DataTypeConversion: '<S947>/Data Type Conversion4' */

  L4_MABX_B.DataTypeConversion4_pe = (L4_MABX_B.Shift_Arithmetic1_g != 0.0);



  /* ArithShift: '<S947>/Shift_Arithmetic 4' */

  L4_MABX_B.Shift_Arithmetic4_o = ldexp(L4_MABX_B.DataType_o, (-5));



  /* DataTypeConversion: '<S947>/Data Type Conversion7' */

  L4_MABX_B.DataTypeConversion7_hc = (L4_MABX_B.Shift_Arithmetic4_o != 0.0);



  /* DataTypeConversion: '<S950>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_hh = AutonomousOutputEnabled;



  /* Switch: '<S984>/Switch' incorporates:

   *  Constant: '<S984>/Constant'

   *  Constant: '<S984>/Constant1'

   */

  if (L4_MABX_B.DataTypeConversion_hh != 0) {

    L4_MABX_B.Switch_jl = L4_MABX_P.Constant_Value_hq2;

  } else {

    L4_MABX_B.Switch_jl = L4_MABX_P.Constant1_Value_ei;

  }



  /* End of Switch: '<S984>/Switch' */



  /* DataTypeConversion: '<S982>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_e3 = L4_MABX_B.Switch_jl;



  /* RelationalOperator: '<S1001>/Operator' incorporates:

   *  Constant: '<S983>/Constant'

   *  Constant: '<S983>/Constant6'

   */

  L4_MABX_B.Operator_l5 = (PROPB_REAX_1_E4_DESIRED_OPMODE_APV ==

    L4_MABX_P.Constant_Value_dc);



  /* Outputs for Enabled SubSystem: '<S983>/DEFAULT_TRQ_CTRL_MODE' */

  L4_MABX_ALL_CTRL_DISABLED(L4_MABX_B.Operator_l5, &L4_MABX_B.Merge,

    &L4_MABX_P.DEFAULT_TRQ_CTRL_MODE);



  /* End of Outputs for SubSystem: '<S983>/DEFAULT_TRQ_CTRL_MODE' */



  /* Switch: '<S1000>/Switch' incorporates:

   *  Constant: '<S1000>/zero'

   */

  if (L4_MABX_B.DataTypeConversion_hh != 0) {

    /* MultiPortSwitch: '<S1000>/Multiport_Switch' incorporates:

     *  Constant: '<S1000>/Constant1'

     *  Constant: '<S1000>/Constant7'

     */

    switch (PROPB_REAX_1_E4_DES_POS_SIG_SRC_APV) {

     case ENUM_STEERING_POS_SIGNAL_SOURCE_T_SW_EMULATION:

      L4_MABX_B.Multiport_Switch = PROPB_REAX_1_E4_DESIRED_POSITION_APV;

      break;



     case ENUM_STEERING_POS_SIGNAL_SOURCE_T_ESTIMATION:

      L4_MABX_B.Multiport_Switch = L4_MABX_B.Subtract_c1;

      break;



     default:

      L4_MABX_B.Multiport_Switch = PROPB_REAX_1_E4_DESIRED_POSITION_APV;

      break;

    }



    /* End of MultiPortSwitch: '<S1000>/Multiport_Switch' */

    L4_MABX_B.Switch_i = L4_MABX_B.Multiport_Switch;

  } else {

    L4_MABX_B.Switch_i = L4_MABX_P.zero_Value_h;

  }



  /* End of Switch: '<S1000>/Switch' */



  /* RelationalOperator: '<S1010>/Operator_MX' incorporates:

   *  Constant: '<S1010>/MX'

   */

  L4_MABX_B.Operator_MX = (L4_MABX_B.Switch_i > L4_MABX_P.MX_Value);



  /* RelationalOperator: '<S1010>/Operator_MN' incorporates:

   *  Constant: '<S1010>/MN'

   */

  L4_MABX_B.Operator_MN = (L4_MABX_B.Switch_i < L4_MABX_P.MN_Value);



  /* Switch: '<S1010>/Switch2' incorporates:

   *  Constant: '<S1010>/MX'

   *  Switch: '<S1010>/Switch1'

   */

  if (L4_MABX_B.Operator_MX) {

    L4_MABX_B.Switch2 = L4_MABX_P.MX_Value;

  } else {

    if (L4_MABX_B.Operator_MN) {

      /* Switch: '<S1010>/Switch1' incorporates:

       *  Constant: '<S1010>/MN'

       */

      L4_MABX_B.Switch1 = L4_MABX_P.MN_Value;

    } else {

      /* Switch: '<S1010>/Switch1' */

      L4_MABX_B.Switch1 = L4_MABX_B.Switch_i;

    }



    L4_MABX_B.Switch2 = L4_MABX_B.Switch1;

  }



  /* End of Switch: '<S1010>/Switch2' */



  /* DataTypeConversion: '<S1010>/DataType' */

  L4_MABX_B.DataType_gt = L4_MABX_B.Switch2;



  /* RelationalOperator: '<S1002>/Operator' incorporates:

   *  Constant: '<S983>/Constant1'

   *  Constant: '<S983>/Constant6'

   */

  L4_MABX_B.Operator_ag = (PROPB_REAX_1_E4_DESIRED_OPMODE_APV ==

    L4_MABX_P.Constant1_Value_f3);



  /* Outputs for Enabled SubSystem: '<S983>/POSITION_CONTROL_MODE' incorporates:

   *  EnablePort: '<S1011>/Enable'

   */

  if (L4_MABX_B.Operator_ag) {

    /* Product: '<S1011>/Product' incorporates:

     *  Constant: '<S1011>/Constant'

     */

    L4_MABX_B.Product = L4_MABX_B.DataType_gt * L4_MABX_P.Constant_Value_g2;



    /* DataTypeConversion: '<S1011>/Data Type Conversion' */

    PositionFinalLimited = floor(L4_MABX_B.Product);

    if (PositionFinalLimited < 2.147483648E+9) {

      if (PositionFinalLimited >= -2.147483648E+9) {

        i = (int32_T)PositionFinalLimited;

      } else {

        i = MIN_int32_T;

      }

    } else {

      i = MAX_int32_T;

    }



    L4_MABX_B.Merge = i;



    /* End of DataTypeConversion: '<S1011>/Data Type Conversion' */

  }



  /* End of Outputs for SubSystem: '<S983>/POSITION_CONTROL_MODE' */



  /* RelationalOperator: '<S1003>/Operator' incorporates:

   *  Constant: '<S983>/Constant2'

   *  Constant: '<S983>/Constant6'

   */

  L4_MABX_B.Operator_mlc = (PROPB_REAX_1_E4_DESIRED_OPMODE_APV ==

    L4_MABX_P.Constant2_Value_ky);



  /* Outputs for Enabled SubSystem: '<S983>/EXT_TRQ_CTRL_MODE_A' */

  L4_MABX_ALL_CTRL_DISABLED(L4_MABX_B.Operator_mlc, &L4_MABX_B.Merge,

    &L4_MABX_P.EXT_TRQ_CTRL_MODE_A);



  /* End of Outputs for SubSystem: '<S983>/EXT_TRQ_CTRL_MODE_A' */



  /* RelationalOperator: '<S1004>/Operator' incorporates:

   *  Constant: '<S983>/Constant3'

   *  Constant: '<S983>/Constant6'

   */

  L4_MABX_B.Operator_og = (PROPB_REAX_1_E4_DESIRED_OPMODE_APV ==

    L4_MABX_P.Constant3_Value_gn);



  /* Outputs for Enabled SubSystem: '<S983>/ALL_CTRL_DISABLED' */

  L4_MABX_ALL_CTRL_DISABLED(L4_MABX_B.Operator_og, &L4_MABX_B.Merge,

    &L4_MABX_P.ALL_CTRL_DISABLED);



  /* End of Outputs for SubSystem: '<S983>/ALL_CTRL_DISABLED' */



  /* RelationalOperator: '<S1005>/Operator' incorporates:

   *  Constant: '<S983>/Constant4'

   *  Constant: '<S983>/Constant6'

   */

  L4_MABX_B.Operator_hj = (PROPB_REAX_1_E4_DESIRED_OPMODE_APV ==

    L4_MABX_P.Constant4_Value_b5);



  /* Outputs for Enabled SubSystem: '<S983>/EXT_TRQ_CTRL_MODE_B' */

  L4_MABX_ALL_CTRL_DISABLED(L4_MABX_B.Operator_hj, &L4_MABX_B.Merge,

    &L4_MABX_P.EXT_TRQ_CTRL_MODE_B);



  /* End of Outputs for SubSystem: '<S983>/EXT_TRQ_CTRL_MODE_B' */



  /* RelationalOperator: '<S1006>/Operator' incorporates:

   *  Constant: '<S983>/Constant5'

   *  Constant: '<S983>/Constant6'

   */

  L4_MABX_B.Operator_pg = (PROPB_REAX_1_E4_DESIRED_OPMODE_APV ==

    L4_MABX_P.Constant5_Value_k);



  /* Outputs for Enabled SubSystem: '<S983>/EXT_TRQ_CTRL_MODE_C' */

  L4_MABX_ALL_CTRL_DISABLED(L4_MABX_B.Operator_pg, &L4_MABX_B.Merge,

    &L4_MABX_P.EXT_TRQ_CTRL_MODE_C);



  /* End of Outputs for SubSystem: '<S983>/EXT_TRQ_CTRL_MODE_C' */



  /* DataTypeConversion: '<S982>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_a5 = (uint32_T)L4_MABX_B.Merge;



  /* S-Function (sfix_bitop): '<S987>/Operator' */

  L4_MABX_B.Operator_i = L4_MABX_B.DataTypeConversion2_a5 &

    L4_MABX_P.Operator_BitMask_if;



  /* DataTypeConversion: '<S987>/DataType' */

  tmp = L4_MABX_B.Operator_i;

  if (tmp > 255U) {

    tmp = 255U;

  }



  L4_MABX_B.DataType_km = (uint8_T)tmp;



  /* End of DataTypeConversion: '<S987>/DataType' */



  /* S-Function (sfix_bitop): '<S988>/Operator' */

  L4_MABX_B.Operator_f = L4_MABX_B.DataTypeConversion2_a5 &

    L4_MABX_P.Operator_BitMask_kh;



  /* DataTypeConversion: '<S988>/DataType' */

  tmp = L4_MABX_B.Operator_f;

  if (tmp > 65535U) {

    tmp = 65535U;

  }



  L4_MABX_B.DataType_ac = (uint16_T)tmp;



  /* End of DataTypeConversion: '<S988>/DataType' */



  /* ArithShift: '<S982>/Shift_Arithmetic ' */

  L4_MABX_B.Shift_Arithmetic_fy = (uint16_T)((uint32_T)L4_MABX_B.DataType_ac >>

    8);



  /* DataTypeConversion: '<S982>/Data Type Conversion4' */

  tmp_0 = L4_MABX_B.Shift_Arithmetic_fy;

  if (tmp_0 > 255) {

    tmp_0 = 255U;

  }



  L4_MABX_B.DataTypeConversion4_o = (uint8_T)tmp_0;



  /* End of DataTypeConversion: '<S982>/Data Type Conversion4' */



  /* S-Function (sfix_bitop): '<S989>/Operator' */

  L4_MABX_B.Operator_a = L4_MABX_B.DataTypeConversion2_a5 &

    L4_MABX_P.Operator_BitMask_be;



  /* DataTypeConversion: '<S989>/DataType' */

  L4_MABX_B.DataType_am = L4_MABX_B.Operator_a;



  /* ArithShift: '<S982>/Shift_Arithmetic 1' */

  L4_MABX_B.Shift_Arithmetic1_n = L4_MABX_B.DataType_am >> 16;



  /* DataTypeConversion: '<S982>/Data Type Conversion5' */

  tmp = L4_MABX_B.Shift_Arithmetic1_n;

  if (tmp > 255U) {

    tmp = 255U;

  }



  L4_MABX_B.DataTypeConversion5_k = (uint8_T)tmp;



  /* End of DataTypeConversion: '<S982>/Data Type Conversion5' */



  /* S-Function (sfix_bitop): '<S990>/Operator' */

  L4_MABX_B.Operator_e = L4_MABX_B.DataTypeConversion2_a5 &

    L4_MABX_P.Operator_BitMask_ai;



  /* DataTypeConversion: '<S990>/DataType' */

  L4_MABX_B.DataType_h = L4_MABX_B.Operator_e;



  /* ArithShift: '<S982>/Shift_Arithmetic 2' */

  L4_MABX_B.Shift_Arithmetic2_ar = L4_MABX_B.DataType_h >> 24;



  /* DataTypeConversion: '<S982>/Data Type Conversion6' */

  tmp = L4_MABX_B.Shift_Arithmetic2_ar;

  if (tmp > 255U) {

    tmp = 255U;

  }



  L4_MABX_B.DataTypeConversion6_i = (uint8_T)tmp;



  /* End of DataTypeConversion: '<S982>/Data Type Conversion6' */



  /* Reshape: '<S1012>/Reshape' incorporates:

   *  Constant: '<S1012>/Constant'

   */

  for (i = 0; i < 16; i++) {

    L4_MABX_B.Reshape_ik[i] = L4_MABX_P.Repeating_Sequence_Stair_OutV_g[i];

  }



  /* End of Reshape: '<S1012>/Reshape' */



  /* UnitDelay: '<S1012>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_n1 = L4_MABX_DW.Unit_Delay_DSTATE_mr;



  /* UnitDelay: '<S1013>/Unit Delay' */

  L4_MABX_B.UnitDelay_a = L4_MABX_DW.UnitDelay_DSTATE_c;



  /* Switch: '<S1016>/Switch1' incorporates:

   *  Constant: '<S1013>/E'

   *  Constant: '<S1013>/IV'

   *  Switch: '<S1015>/Switch1'

   */

  if (L4_MABX_B.Unit_Delay_n1) {

    L4_MABX_B.Switch1_a = L4_MABX_P.IV_Value_ms;

  } else {

    if (L4_MABX_P.E_Value_a) {

      /* Sum: '<S1013>/Subtract' incorporates:

       *  Constant: '<S1013>/Constant'

       *  Switch: '<S1015>/Switch1'

       */

      q0 = L4_MABX_P.Constant_Value_oi;

      tmp = q0 + L4_MABX_B.UnitDelay_a;

      if (tmp < q0) {

        tmp = MAX_uint32_T;

      }



      L4_MABX_B.Subtract_ou = tmp;



      /* End of Sum: '<S1013>/Subtract' */



      /* Switch: '<S1015>/Switch1' */

      L4_MABX_B.Switch1_b = L4_MABX_B.Subtract_ou;

    } else {

      /* Switch: '<S1015>/Switch1' */

      L4_MABX_B.Switch1_b = L4_MABX_B.UnitDelay_a;

    }



    L4_MABX_B.Switch1_a = L4_MABX_B.Switch1_b;

  }



  /* End of Switch: '<S1016>/Switch1' */



  /* Selector: '<S1012>/Selector' */

  L4_MABX_B.Selector_o = L4_MABX_B.Reshape_ik[(int32_T)L4_MABX_B.Switch1_a - 1];



  /* DataTypeConversion: '<S982>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_gn = L4_MABX_B.Selector_o;



  /* S-Function (sfix_bitop): '<S995>/Operator' */

  L4_MABX_B.Operator_k4 = (uint8_T)(L4_MABX_B.DataTypeConversion1_gn &

    L4_MABX_P.Operator_BitMask_de);



  /* DataTypeConversion: '<S995>/DataType' */

  L4_MABX_B.DataType_g4 = L4_MABX_B.Operator_k4;



  /* DataTypeConversion: '<S981>/Data Type Conversion' incorporates:

   *  Constant: '<S981>/Priority'

   */

  L4_MABX_B.DataTypeConversion_h = L4_MABX_P.Priority_Value_l;



  /* ArithShift: '<S981>/Shift_Arithmetic ' */

  L4_MABX_B.Shift_Arithmetic_a = L4_MABX_B.DataTypeConversion_h << 26;



  /* DataTypeConversion: '<S981>/Data Type Conversion1' incorporates:

   *  Constant: '<S981>/ExtendedDataPage'

   */

  L4_MABX_B.DataTypeConversion1_ha = L4_MABX_P.ExtendedDataPage_Value_n;



  /* ArithShift: '<S981>/Shift_Arithmetic 1' */

  L4_MABX_B.Shift_Arithmetic1_e = L4_MABX_B.DataTypeConversion1_ha << 25;



  /* DataTypeConversion: '<S981>/Data Type Conversion2' incorporates:

   *  Constant: '<S981>/DataPage'

   */

  L4_MABX_B.DataTypeConversion2_om = L4_MABX_P.DataPage_Value_p;



  /* ArithShift: '<S981>/Shift_Arithmetic 2' */

  L4_MABX_B.Shift_Arithmetic2_d = L4_MABX_B.DataTypeConversion2_om << 24;



  /* DataTypeConversion: '<S981>/Data Type Conversion3' incorporates:

   *  Constant: '<S981>/PDUFormat'

   */

  L4_MABX_B.DataTypeConversion3_i = L4_MABX_P.PDUFormat_Value_b;



  /* ArithShift: '<S981>/Shift_Arithmetic 3' */

  L4_MABX_B.Shift_Arithmetic3_h = L4_MABX_B.DataTypeConversion3_i << 16;



  /* DataTypeConversion: '<S981>/Data Type Conversion4' incorporates:

   *  Constant: '<S981>/PDUSpecific'

   */

  L4_MABX_B.DataTypeConversion4_b5 = L4_MABX_P.PDUSpecific_Value_j;



  /* ArithShift: '<S981>/Shift_Arithmetic 4' */

  L4_MABX_B.Shift_Arithmetic4_nx = L4_MABX_B.DataTypeConversion4_b5 << 8;



  /* DataTypeConversion: '<S981>/Data Type Conversion5' incorporates:

   *  Constant: '<S981>/SourceAddress'

   */

  L4_MABX_B.DataTypeConversion5_c = L4_MABX_P.SourceAddress_Value_p;



  /* S-Function (sfix_bitop): '<S986>/Operator' */

  L4_MABX_B.Operator_l = L4_MABX_B.Shift_Arithmetic_a |

    L4_MABX_B.Shift_Arithmetic1_e | L4_MABX_B.Shift_Arithmetic2_d |

    L4_MABX_B.Shift_Arithmetic3_h | L4_MABX_B.Shift_Arithmetic4_nx |

    L4_MABX_B.DataTypeConversion5_c;



  /* DataTypeConversion: '<S986>/DataType' */

  L4_MABX_B.DataType_jf = L4_MABX_B.Operator_l;



  /* DataTypeConversion: '<S982>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_mr = L4_MABX_B.DataType_jf;



  /* S-Function (sfix_bitop): '<S991>/Operator' */

  L4_MABX_B.Operator_n = L4_MABX_B.DataTypeConversion3_mr &

    L4_MABX_P.Operator_BitMask_kt;



  /* DataTypeConversion: '<S991>/DataType' */

  tmp = L4_MABX_B.Operator_n;

  if (tmp > 255U) {

    tmp = 255U;

  }



  L4_MABX_B.DataType_ea = (uint8_T)tmp;



  /* End of DataTypeConversion: '<S991>/DataType' */



  /* S-Function (sfix_bitop): '<S992>/Operator' */

  L4_MABX_B.Operator_ar = L4_MABX_B.DataTypeConversion3_mr &

    L4_MABX_P.Operator_BitMask_en;



  /* DataTypeConversion: '<S992>/DataType' */

  tmp = L4_MABX_B.Operator_ar;

  if (tmp > 65535U) {

    tmp = 65535U;

  }



  L4_MABX_B.DataType_ew = (uint16_T)tmp;



  /* End of DataTypeConversion: '<S992>/DataType' */



  /* ArithShift: '<S982>/Shift_Arithmetic 3' */

  L4_MABX_B.Shift_Arithmetic3_eh = (uint16_T)((uint32_T)L4_MABX_B.DataType_ew >>

    8);



  /* DataTypeConversion: '<S982>/Data Type Conversion8' */

  tmp_0 = L4_MABX_B.Shift_Arithmetic3_eh;

  if (tmp_0 > 255) {

    tmp_0 = 255U;

  }



  L4_MABX_B.DataTypeConversion8_g = (uint8_T)tmp_0;



  /* End of DataTypeConversion: '<S982>/Data Type Conversion8' */



  /* S-Function (sfix_bitop): '<S993>/Operator' */

  L4_MABX_B.Operator_db = L4_MABX_B.DataTypeConversion3_mr &

    L4_MABX_P.Operator_BitMask_et;



  /* DataTypeConversion: '<S993>/DataType' */

  L4_MABX_B.DataType_hs = L4_MABX_B.Operator_db;



  /* ArithShift: '<S982>/Shift_Arithmetic 4' */

  L4_MABX_B.Shift_Arithmetic4_nb = L4_MABX_B.DataType_hs >> 16;



  /* DataTypeConversion: '<S982>/Data Type Conversion9' */

  tmp = L4_MABX_B.Shift_Arithmetic4_nb;

  if (tmp > 255U) {

    tmp = 255U;

  }



  L4_MABX_B.DataTypeConversion9_d = (uint8_T)tmp;



  /* End of DataTypeConversion: '<S982>/Data Type Conversion9' */



  /* S-Function (sfix_bitop): '<S994>/Operator' */

  L4_MABX_B.Operator_h = L4_MABX_B.DataTypeConversion3_mr &

    L4_MABX_P.Operator_BitMask_it;



  /* DataTypeConversion: '<S994>/DataType' */

  L4_MABX_B.DataType_kr = L4_MABX_B.Operator_h;



  /* ArithShift: '<S982>/Shift_Arithmetic 5' */

  L4_MABX_B.Shift_Arithmetic5_i = L4_MABX_B.DataType_kr >> 24;



  /* DataTypeConversion: '<S982>/Data Type Conversion10' */

  tmp = L4_MABX_B.Shift_Arithmetic5_i;

  if (tmp > 255U) {

    tmp = 255U;

  }



  L4_MABX_B.DataTypeConversion10_n = (uint8_T)tmp;



  /* End of DataTypeConversion: '<S982>/Data Type Conversion10' */



  /* Sum: '<S982>/Add' incorporates:

   *  Constant: '<S982>/Constant'

   *  Constant: '<S982>/Constant1'

   */

  L4_MABX_B.Add_aut = (uint8_T)((uint32_T)(uint8_T)((uint32_T)(uint8_T)

    ((uint32_T)(uint8_T)((uint32_T)(uint8_T)((uint32_T)(uint8_T)((uint32_T)

    (uint8_T)((uint32_T)(uint8_T)((uint32_T)(uint8_T)((uint32_T)(uint8_T)

    ((uint32_T)(uint8_T)((uint32_T)L4_MABX_B.DataTypeConversion_e3 +

    L4_MABX_B.DataType_km) + L4_MABX_B.DataTypeConversion4_o) +

    L4_MABX_B.DataTypeConversion5_k) + L4_MABX_B.DataTypeConversion6_i) +

              L4_MABX_P.Constant_Value_dx) + L4_MABX_P.Constant1_Value_ef) +

    L4_MABX_B.DataType_ea) + L4_MABX_B.DataTypeConversion8_g) +

     L4_MABX_B.DataTypeConversion9_d) + L4_MABX_B.DataTypeConversion10_n) +

    L4_MABX_B.DataType_g4);



  /* ArithShift: '<S982>/Shift_Arithmetic 6' */

  L4_MABX_B.Shift_Arithmetic6_j = (uint8_T)((uint32_T)L4_MABX_B.Add_aut >> 4);



  /* Sum: '<S982>/Add1' */

  L4_MABX_B.Add1_j = (uint8_T)((uint32_T)L4_MABX_B.Shift_Arithmetic6_j +

    L4_MABX_B.Add_aut);



  /* S-Function (sfix_bitop): '<S996>/Operator' */

  L4_MABX_B.Operator_jn = (uint8_T)(L4_MABX_B.Add1_j &

    L4_MABX_P.Operator_BitMask_po);



  /* DataTypeConversion: '<S996>/DataType' */

  L4_MABX_B.DataType_e5 = L4_MABX_B.Operator_jn;



  /* ArithShift: '<S982>/Shift_Arithmetic 7' */

  L4_MABX_B.Shift_Arithmetic7_e = (uint8_T)(L4_MABX_B.DataType_e5 << 4);



  /* S-Function (sfix_bitop): '<S997>/Operator' */

  L4_MABX_B.Operator_f2 = (uint8_T)(L4_MABX_B.DataType_g4 |

    L4_MABX_B.Shift_Arithmetic7_e);



  /* DataTypeConversion: '<S997>/DataType' */

  L4_MABX_B.DataType_ci = L4_MABX_B.Operator_f2;



  /* DataTypeConversion: '<S948>/Data Type Conversion1' incorporates:

   *  Constant: '<S982>/Constant'

   *  Constant: '<S982>/Constant1'

   */

  L4_MABX_B.DataTypeConversion1_j[0] = L4_MABX_B.DataTypeConversion_e3;

  L4_MABX_B.DataTypeConversion1_j[1] = L4_MABX_B.DataType_km;

  L4_MABX_B.DataTypeConversion1_j[2] = L4_MABX_B.DataTypeConversion4_o;

  L4_MABX_B.DataTypeConversion1_j[3] = L4_MABX_B.DataTypeConversion5_k;

  L4_MABX_B.DataTypeConversion1_j[4] = L4_MABX_B.DataTypeConversion6_i;

  L4_MABX_B.DataTypeConversion1_j[5] = L4_MABX_P.Constant_Value_dx;

  L4_MABX_B.DataTypeConversion1_j[6] = L4_MABX_P.Constant1_Value_ef;

  L4_MABX_B.DataTypeConversion1_j[7] = L4_MABX_B.DataType_ci;



  /* Outputs for Enabled SubSystem: '<S969>/PropB_REAX_1_E4' incorporates:

   *  EnablePort: '<S971>/Enable'

   */

  if (L4_MABX_B.Operator_nc) {

    /* S-Function (rti_commonblock): '<S971>/S-Function1' incorporates:

     *  Constant: '<S969>/Constant'

     *  Constant: '<S969>/Constant1'

     */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "PropB_REAX_1_E4" Id:419426276 */

    {

      static UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        0x00 };



      Float32 delayTime = 0.0;



      /* link this pointer to CAN_Msg for use in initialize_io_units() */

      CANTP1_PTR_M1_C2_XTD_0x18FFEFE4 = &(CAN_Msg[0]);



      /* ... perform loop-back if required */

      if (L4_MABX_P.Constant1_Value_lp > 0.5) {

        /* ... updating the used tx-clientbuffer */

        can_tp1_msg_update_all( CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFEFE4->module,

          CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFEFE4->queue );



        /* ... Read status and timestamp info perform loop-back (previous message) */

        can_tp1_tx_msg_read_loopback(CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFEFE4,

          8,                           // datalen

          &(CAN_Msg[0]),

          CANTP1_RX_SPMSG_M1_C2_XTD);



        /* Convert timestamp */

        if (CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFEFE4->processed) {

          CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFEFE4->timestamp =

            rtk_dsts_time_to_simtime_convert

            (CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFEFE4->timestamp);

        }

      } else {

        /* ... Read status and timestamp info (previous message) */

        can_tp1_msg_read_from_dsmcr(CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFEFE4);



        /* Convert timestamp */

        if (CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFEFE4->processed) {

          CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFEFE4->timestamp =

            rtk_dsts_time_to_simtime_convert

            (CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFEFE4->timestamp);

        }

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFEFE4->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_oc = (real_T)

          CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFEFE4->processed;

        L4_MABX_B.SFunction1_o2_c = (real_T)

          CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFEFE4->timestamp;

        L4_MABX_B.SFunction1_o3_f = (real_T)

          CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFEFE4->deltatime;

        L4_MABX_B.SFunction1_o4_n = (real_T)

          CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFEFE4->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;

        UInt32 i;



        /* Initialize the static message data to zero */

        for (i=0; i<8; i++ )

          CAN_Msg[i] = 0;



        /* ...... "byte1" (0|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_j[0] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte2" (8|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_j[1] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte3" (16|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_j[2] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte4" (24|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_j[3] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte5" (32|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_j[4] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte6" (40|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_j[5] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte7" (48|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_j[6] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte8" (56|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_j[7] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;

      }



      delayTime = (Float32) L4_MABX_P.Constant_Value_f4 / (1700);



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M1[CANTP1_M1_C2_TX_XTD_0X18FFEFE4], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  /* End of Outputs for SubSystem: '<S969>/PropB_REAX_1_E4' */



  /* Outputs for Enabled SubSystem: '<S970>/PropB_REAX_1_E4' incorporates:

   *  EnablePort: '<S972>/Enable'

   */

  if (L4_MABX_B.EnablePropB_ReAX_CAN6) {

    /* S-Function (rti_commonblock): '<S972>/S-Function1' incorporates:

     *  Constant: '<S970>/Constant'

     *  Constant: '<S970>/Constant1'

     */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "PropB_REAX_1_E4" Id:419426276 */

    {

      static UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        0x00 };



      Float32 delayTime = 0.0;



      /* link this pointer to CAN_Msg for use in initialize_io_units() */

      CANTP1_PTR_M3_C2_XTD_0x18FFEFE4 = &(CAN_Msg[0]);



      /* ... perform loop-back if required */

      if (L4_MABX_P.Constant1_Value_ad > 0.5) {

        /* ... updating the used tx-clientbuffer */

        can_tp1_msg_update_all( CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFEFE4->module,

          CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFEFE4->queue );



        /* ... Read status and timestamp info perform loop-back (previous message) */

        can_tp1_tx_msg_read_loopback(CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFEFE4,

          8,                           // datalen

          &(CAN_Msg[0]),

          CANTP1_RX_SPMSG_M3_C2_XTD);



        /* Convert timestamp */

        if (CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFEFE4->processed) {

          CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFEFE4->timestamp =

            rtk_dsts_time_to_simtime_convert

            (CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFEFE4->timestamp);

        }

      } else {

        /* ... Read status and timestamp info (previous message) */

        can_tp1_msg_read_from_dsmcr(CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFEFE4);



        /* Convert timestamp */

        if (CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFEFE4->processed) {

          CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFEFE4->timestamp =

            rtk_dsts_time_to_simtime_convert

            (CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFEFE4->timestamp);

        }

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFEFE4->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_m = (real_T)

          CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFEFE4->processed;

        L4_MABX_B.SFunction1_o2_gj = (real_T)

          CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFEFE4->timestamp;

        L4_MABX_B.SFunction1_o3_mj = (real_T)

          CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFEFE4->deltatime;

        L4_MABX_B.SFunction1_o4_j = (real_T)

          CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFEFE4->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;

        UInt32 i;



        /* Initialize the static message data to zero */

        for (i=0; i<8; i++ )

          CAN_Msg[i] = 0;



        /* ...... "byte1" (0|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_j[0] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte2" (8|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_j[1] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte3" (16|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_j[2] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte4" (24|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_j[3] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte5" (32|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_j[4] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte6" (40|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_j[5] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte7" (48|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_j[6] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte8" (56|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_j[7] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;

      }



      delayTime = (Float32) L4_MABX_P.Constant_Value_em / (1700);



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M3[CANTP1_M3_C2_TX_XTD_0X18FFEFE4], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  /* End of Outputs for SubSystem: '<S970>/PropB_REAX_1_E4' */



  /* DataTypeConversion: '<S949>/Data Type Conversion' incorporates:

   *  Constant: '<S860>/CANT_VDC2_0B_CHANNEL_APV'

   */

  L4_MABX_B.DataTypeConversion_ng = (uint8_T)

    L4_MABX_P.CANT_VDC2_0B_CHANNEL_APV_Value;



  /* S-Function (sfix_bitop): '<S977>/Operator' */

  L4_MABX_B.Operator_iq = (uint8_T)(L4_MABX_B.DataTypeConversion_ng &

    L4_MABX_P.Operator_BitMask_hp);



  /* DataTypeConversion: '<S977>/DataType' */

  L4_MABX_B.DataType_l0 = L4_MABX_B.Operator_iq;



  /* ArithShift: '<S949>/Shift_Arithmetic 3' */

  L4_MABX_B.Shift_Arithmetic3_f = ldexp(L4_MABX_B.DataType_l0, (-4));



  /* DataTypeConversion: '<S949>/Data Type Conversion6' */

  L4_MABX_B.DataTypeConversion6_ki = (L4_MABX_B.Shift_Arithmetic3_f != 0.0);



  /* Outputs for Enabled SubSystem: '<S979>/VDC2_0B' incorporates:

   *  EnablePort: '<S980>/Enable'

   */

  if (L4_MABX_B.DataTypeConversion6_ki) {

    /* S-Function (rti_commonblock): '<S980>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "VDC2_0B" Id:418384139 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18F0090B]);



      /* Convert timestamp */

      if (can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18F0090B]->processed) {

        can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18F0090B]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18F0090B]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18F0090B]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_l1 = (real_T)

          can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18F0090B]->processed;

        L4_MABX_B.SFunction1_o2_er = (real_T)

          can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18F0090B]->timestamp;

        L4_MABX_B.SFunction1_o3_bp = (real_T)

          can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18F0090B]->deltatime;

        L4_MABX_B.SFunction1_o4_m = (real_T)

          can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18F0090B]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "SteerWheelAngle" (0|16, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( SteerWheelAngle - ( -31.374 ) ) /

          0.0009765625 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte1;



        /* ...... "SteerWheelTurnCounter" (16|6, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (L4_MABX_B.SFunction1_o2_gn - ( -32 ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000003F;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SteerWheelAngleSensorType" (22|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.SFunction1_o3_jk ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "YawRate" (24|16, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( YawRate - ( -3.92 ) ) /

          0.0001220703125 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte1;



        /* ...... "LateralAcceleration" (40|16, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.SFunction1_o5_f - ( -15.687 )

          ) / 0.00048828125 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte1;



        /* ...... "LongitudinalAcceleration" (56|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( SPN1810_LongitudinalAcceleration -

          ( -12.5 ) ) / 0.1 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;

      }



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18F0090B], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  /* End of Outputs for SubSystem: '<S979>/VDC2_0B' */



  /* S-Function (sfix_bitop): '<S973>/Operator' */

  L4_MABX_B.Operator_ev = (uint8_T)(L4_MABX_B.DataTypeConversion_ng &

    L4_MABX_P.Operator_BitMask_cl);



  /* DataTypeConversion: '<S973>/DataType' */

  L4_MABX_B.DataType_n1 = L4_MABX_B.Operator_ev;



  /* S-Function (sfix_bitop): '<S974>/Operator' */

  L4_MABX_B.Operator_ms = (uint8_T)(L4_MABX_B.DataTypeConversion_ng &

    L4_MABX_P.Operator_BitMask_ak);



  /* DataTypeConversion: '<S974>/DataType' */

  L4_MABX_B.DataType_f = L4_MABX_B.Operator_ms;



  /* S-Function (sfix_bitop): '<S975>/Operator' */

  L4_MABX_B.Operator_h1 = (uint8_T)(L4_MABX_B.DataTypeConversion_ng &

    L4_MABX_P.Operator_BitMask_cz);



  /* DataTypeConversion: '<S975>/DataType' */

  L4_MABX_B.DataType_oh = L4_MABX_B.Operator_h1;



  /* S-Function (sfix_bitop): '<S976>/Operator' */

  L4_MABX_B.Operator_iz = (uint8_T)(L4_MABX_B.DataTypeConversion_ng &

    L4_MABX_P.Operator_BitMask_c2);



  /* DataTypeConversion: '<S976>/DataType' */

  L4_MABX_B.DataType_p3 = L4_MABX_B.Operator_iz;



  /* S-Function (sfix_bitop): '<S978>/Operator' */

  L4_MABX_B.Operator_iy = (uint8_T)(L4_MABX_B.DataTypeConversion_ng &

    L4_MABX_P.Operator_BitMask_au);



  /* DataTypeConversion: '<S978>/DataType' */

  L4_MABX_B.DataType_m = L4_MABX_B.Operator_iy;



  /* DataTypeConversion: '<S949>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_nr = (L4_MABX_B.DataType_n1 != 0);



  /* ArithShift: '<S949>/Shift_Arithmetic ' */

  L4_MABX_B.Shift_Arithmetic_j = ldexp(L4_MABX_B.DataType_f, (-1));



  /* DataTypeConversion: '<S949>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_f2 = (L4_MABX_B.Shift_Arithmetic_j != 0.0);



  /* ArithShift: '<S949>/Shift_Arithmetic 1' */

  L4_MABX_B.Shift_Arithmetic1_k = ldexp(L4_MABX_B.DataType_oh, (-2));



  /* DataTypeConversion: '<S949>/Data Type Conversion4' */

  L4_MABX_B.DataTypeConversion4_ox = (L4_MABX_B.Shift_Arithmetic1_k != 0.0);



  /* ArithShift: '<S949>/Shift_Arithmetic 2' */

  L4_MABX_B.Shift_Arithmetic2_m = ldexp(L4_MABX_B.DataType_p3, (-3));



  /* DataTypeConversion: '<S949>/Data Type Conversion5' */

  L4_MABX_B.DataTypeConversion5_me = (L4_MABX_B.Shift_Arithmetic2_m != 0.0);



  /* ArithShift: '<S949>/Shift_Arithmetic 4' */

  L4_MABX_B.Shift_Arithmetic4_om = ldexp(L4_MABX_B.DataType_m, (-5));



  /* DataTypeConversion: '<S949>/Data Type Conversion7' */

  L4_MABX_B.DataTypeConversion7_ef = (L4_MABX_B.Shift_Arithmetic4_om != 0.0);



  /* Logic: '<S1010>/Logical Operator1' */

  L4_MABX_B.LogicalOperator1_cr = !L4_MABX_B.Operator_MX;



  /* Logic: '<S1010>/Logical Operator' */

  L4_MABX_B.LogicalOperator_i1 = (L4_MABX_B.LogicalOperator1_cr &&

    L4_MABX_B.Operator_MN);



  /* RelationalOperator: '<S1014>/Operator' */

  L4_MABX_B.Operator_k1o = (L4_MABX_B.Switch1_a == L4_MABX_B.Width_j);



  /* End of Outputs for SubSystem: '<S855>/CAN_TX_10ms' */



  /* Outputs for Atomic SubSystem: '<S855>/CAN_TX_20ms' */



  /* RateTransition: '<S1021>/TmpRTBAtDivide1Inport1' */

  if (L4_MABX_M->Timing.RateInteraction.TID0_1 == 1) {

    L4_MABX_B.BrakingPID_Y_g = L4_MABX_B.BrakingPID_Y_k;

    L4_MABX_B.AutonomousOutputEnabled_h = AutonomousOutputEnabled;

    L4_MABX_B.BrakingControlActive_b = L4_MABX_B.F_Brake_control_active;

    L4_MABX_B.TmpRTBAtLogicalOperator8Inport1 = AutonomousOutputEnabled;

    L4_MABX_B.TmpRTBAtLogicalOperator1Inport2 = AutonomousOutputEnabled;

    L4_MABX_B.TmpRTBAtUnit_DelayInport1 = AutonomousOutputEnabled;

    L4_MABX_B.BrakingPID_Y_gc = L4_MABX_B.BrakingPID_Y_k;

    L4_MABX_B.FrontAxleSpeed_b = L4_MABX_B.SFunction1_o1_gd;

    L4_MABX_B.SPN1807_SteeringWheelAngle_g = SteerWheelAngle;

    L4_MABX_B.SPN1808_YawRate_i = YawRate;

    L4_MABX_B.SPN1810_LongitudinalAccelerat_i = SPN1810_LongitudinalAcceleration;

  }



  /* End of Outputs for SubSystem: '<S855>/CAN_TX_20ms' */



  /* Outputs for Atomic SubSystem: '<S855>/CAN_TX_5000ms' */



  /* RateTransition: '<S1050>/TmpRTBAtOperatorInport2' */

  if (L4_MABX_M->Timing.RateInteraction.TID0_7 == 1) {

    L4_MABX_B.TmpRTBAtOperatorInport2 = AutonomousOutputEnabled;

  }



  /* End of RateTransition: '<S1050>/TmpRTBAtOperatorInport2' */



  /* End of Outputs for SubSystem: '<S855>/CAN_TX_5000ms' */



  /* Outputs for Enabled SubSystem: '<S646>/TC1_03_05' incorporates:

   *  EnablePort: '<S647>/Enable'

   */

  /* Constant: '<S461>/Constant' */

  if (L4_MABX_P.Constant_Value_cu) {

    /* S-Function (rti_commonblock): '<S647>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "TC1_03_05" Id:201392901 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M3_C1_XTD[CANTP1_M3_C1_RXSRVC_XTD_0xC010305].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M3_C1_XTD[CANTP1_M3_C1_RXSRVC_XTD_0xC010305].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o26 = 1.0;

        L4_MABX_B.SFunction1_o27 = (real_T)

          can_type1_M3_C1_XTD[CANTP1_M3_C1_RXSRVC_XTD_0xC010305].timestamp;

        L4_MABX_B.SFunction1_o28 = (real_T)

          can_type1_M3_C1_XTD[CANTP1_M3_C1_RXSRVC_XTD_0xC010305].deltatime;

        CAN_Msg = can_type1_M3_C1_XTD[CANTP1_M3_C1_RXSRVC_XTD_0xC010305].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "SPN681_TransGearShiftInhibitReq" (0|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o1_iz = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN682_TransTrqConvLockupDisReq" (2|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o2_k5 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN683_DisengageDrivelineReq" (4|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o3_edr = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN4242_TransRevGearShiftInhibRq" (6|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o4_lb = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN684_RequestedPercClutchSlip" (8|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o5_n = 0.4 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "SPN525_TransRequestedGear" (16|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o6_b = -125 + ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "SPN685_DisengageDiffLockRqFrAx1" (24|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o7_c = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN686_DisengageDiffLockRqFrAx2" (26|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o8_l = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN687_DisengageDiffLockRqRrAx1" (28|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o9_j = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN688_DisengageDiffLockRqRrAx2" (30|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o10_h = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN689_DisengageDiffLockRqC" (32|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o11 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN690_DisengageDiffLockRqCF" (34|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o12 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN691_DisengageDiffLockRqCR" (36|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o13 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN5762_TransLoadRedInhibitRq" (38|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o14 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN1852_TransmissionMode1" (40|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o15 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN1853_TransmissionMode2" (42|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o16 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN1854_TransmissionMode3" (44|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o17 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN1855_TransmissionMode4" (46|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o18 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN7695_TransAutoNeutralRequest" (48|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o19 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN4255_TransRequestedLaunchGear" (50|4, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x0000000F;

            L4_MABX_B.SFunction1_o20 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN2985_TransShiftSelDispModeSw" (54|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o21 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN4246_TransmissionMode5" (56|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o22 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN4247_TransmissionMode6" (58|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o23 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN4248_TransmissionMode7" (60|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o24 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN4249_TransmissionMode8" (62|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o25 = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o26 = 0.0;

      }

    }

  }



  /* End of Constant: '<S461>/Constant' */

  /* End of Outputs for SubSystem: '<S646>/TC1_03_05' */



  /* Outputs for Atomic SubSystem: '<S855>/CAN_TX_50ms' */



  /* RateTransition: '<S1060>/TmpRTBAtCCVS1_E3Inport1' */

  if (L4_MABX_M->Timing.RateInteraction.TID0_2 == 1) {

    L4_MABX_B.TwoSpeedAxleSwitch = L4_MABX_B.SFunction1_o1_g3;

    L4_MABX_B.ParkingBrakeSwitch = L4_MABX_B.SFunction1_o2_g4;

    L4_MABX_B.CruiseCtrlPauseSwitch = L4_MABX_B.SFunction1_o3_ne;

    L4_MABX_B.ParkBrakeReleaseInhibitRq = L4_MABX_B.SFunction1_o4_e3;

    L4_MABX_B.WheelBasedVehicleSpeed_p = WheelBasedVehicleSpeed;

    L4_MABX_B.CruiseCtrlActive = L4_MABX_B.SFunction1_o6_oc;

    L4_MABX_B.CruiseCtrlEnableSwitch_n = L4_MABX_B.SFunction1_o7_dk;

    L4_MABX_B.BrakeSwitch_n = BrakeSwitch;

    L4_MABX_B.ClutchSwitch = L4_MABX_B.SFunction1_o9_p;

    L4_MABX_B.CruiseCtrlSetSwitch = L4_MABX_B.SFunction1_o10_or;

    L4_MABX_B.CruiseCtrlCoastSwitch = L4_MABX_B.SFunction1_o11_ae;

    L4_MABX_B.CruiseCtrlResumeSwitch = L4_MABX_B.SFunction1_o12_jy;

    L4_MABX_B.CruiseCtrlAccelerateSwitch = L4_MABX_B.SFunction1_o13_ou;

    L4_MABX_B.CruiseCtrlSetSpeed = L4_MABX_B.SFunction1_o14_b;

    L4_MABX_B.PTOGovernorState = L4_MABX_B.SFunction1_o15_dd;

    L4_MABX_B.CruiseCtrlStates = L4_MABX_B.SFunction1_o16_g;

    L4_MABX_B.EngIdleIncrementSwitch = L4_MABX_B.SFunction1_o17_n;

    L4_MABX_B.EngIdleDecrementSwitch = L4_MABX_B.SFunction1_o18_g;

    L4_MABX_B.EngTestModeSwitch = L4_MABX_B.SFunction1_o19_a;

    L4_MABX_B.EngShutdownOverrideSwitch = L4_MABX_B.SFunction1_o20_ir;

    L4_MABX_B.SPN681_TransGearShiftInhibitReq = L4_MABX_B.SFunction1_o1_iz;

    L4_MABX_B.SPN682_TransTrqConvLockupDisReq = L4_MABX_B.SFunction1_o2_k5;

    L4_MABX_B.SPN683_DisengageDrivelineReq = L4_MABX_B.SFunction1_o3_edr;

    L4_MABX_B.SPN4242_TransRevGearShiftInhibR = L4_MABX_B.SFunction1_o4_lb;

    L4_MABX_B.SPN684_RequestedPercClutchSlip = L4_MABX_B.SFunction1_o5_n;

    L4_MABX_B.SPN525_TransRequestedGear = L4_MABX_B.SFunction1_o6_b;

    L4_MABX_B.SPN685_DisengageDiffLockRqFrAx1 = L4_MABX_B.SFunction1_o7_c;

    L4_MABX_B.SPN686_DisengageDiffLockRqFrAx2 = L4_MABX_B.SFunction1_o8_l;

    L4_MABX_B.SPN687_DisengageDiffLockRqRrAx1 = L4_MABX_B.SFunction1_o9_j;

    L4_MABX_B.SPN688_DisengageDiffLockRqRrAx2 = L4_MABX_B.SFunction1_o10_h;

    L4_MABX_B.SPN689_DisengageDiffLockRqC = L4_MABX_B.SFunction1_o11;

    L4_MABX_B.SPN690_DisengageDiffLockRqCF = L4_MABX_B.SFunction1_o12;

    L4_MABX_B.SPN691_DisengageDiffLockRqCR = L4_MABX_B.SFunction1_o13;

    L4_MABX_B.SPN5762_TransLoadRedInhibitRq = L4_MABX_B.SFunction1_o14;

    L4_MABX_B.SPN1852_TransmissionMode1 = L4_MABX_B.SFunction1_o15;

    L4_MABX_B.SPN1853_TransmissionMode2 = L4_MABX_B.SFunction1_o16;

    L4_MABX_B.SPN1854_TransmissionMode3 = L4_MABX_B.SFunction1_o17;

    L4_MABX_B.SPN1855_TransmissionMode4 = L4_MABX_B.SFunction1_o18;

    L4_MABX_B.SPN7695_TransAutoNeutralRequest = L4_MABX_B.SFunction1_o19;

    L4_MABX_B.SPN4255_TransRequestedLaunchGea = L4_MABX_B.SFunction1_o20;

    L4_MABX_B.SPN2985_TransShiftSelDispModeSw = L4_MABX_B.SFunction1_o21;

    L4_MABX_B.SPN4246_TransmissionMode5 = L4_MABX_B.SFunction1_o22;

    L4_MABX_B.SPN4247_TransmissionMode6 = L4_MABX_B.SFunction1_o23;

    L4_MABX_B.SPN4248_TransmissionMode7 = L4_MABX_B.SFunction1_o24;

    L4_MABX_B.SPN4249_TransmissionMode8 = L4_MABX_B.SFunction1_o25;

  }



  /* End of Outputs for SubSystem: '<S855>/CAN_TX_50ms' */



  /* Outputs for Enabled SubSystem: '<S644>/SystemTime_01' incorporates:

   *  EnablePort: '<S645>/Enable'

   */

  /* Constant: '<S460>/Constant' */

  if (L4_MABX_P.Constant_Value_ix > 0.0) {

    /* S-Function (rti_commonblock): '<S645>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "SystemTime_01" Id:233836544 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0xDF01000].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0xDF01000].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o5_g = 1.0;

        L4_MABX_B.SFunction1_o6_k = (real_T)

          can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0xDF01000].timestamp;

        L4_MABX_B.SFunction1_o7_e = (real_T)

          can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0xDF01000].deltatime;

        CAN_Msg = can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0xDF01000].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "SID" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_os = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "Source" (8|4, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x0000000F;

            L4_MABX_B.SFunction1_o2_ly = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "Date" (16|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o3_g = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "Time" (32|32, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

            CAN_Sgn.SgnBytes.Byte2 = CAN_Msg[6];

            CAN_Sgn.SgnBytes.Byte3 = CAN_Msg[7];

            L4_MABX_B.SFunction1_o4_hf = 0.0001 * ( ((real_T)

              CAN_Sgn.UnsignedSgn) );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o5_g = 0.0;

      }

    }

  }



  /* End of Constant: '<S460>/Constant' */

  /* End of Outputs for SubSystem: '<S644>/SystemTime_01' */



  /* DataTypeConversion: '<S644>/Data Type Conversion8' */

  L4_MABX_B.RX_status_g = (L4_MABX_B.SFunction1_o5_g != 0.0);



  /* Logic: '<S1074>/Operator' incorporates:

   *  Constant: '<S1072>/Constant'

   */

  L4_MABX_B.Operator_fh = (L4_MABX_P.Constant_Value_cr && L4_MABX_B.RX_status_g);



  /* DataTypeConversion: '<S1074>/DataType' */

  L4_MABX_B.DataType_kox = L4_MABX_B.Operator_fh;



  /* Outputs for Enabled SubSystem: '<S1073>/Std_SystemTime_01' incorporates:

   *  EnablePort: '<S1075>/Enable'

   */

  if (L4_MABX_B.DataType_kox) {

    /* S-Function (rti_commonblock): '<S1075>/S-Function1' incorporates:

     *  Constant: '<S1073>/Constant'

     *  Constant: '<S1073>/Constant1'

     */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "Std_SystemTime_01" Id:5 */

    {

      static UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        0x00 };



      Float32 delayTime = 0.0;



      /* link this pointer to CAN_Msg for use in initialize_io_units() */

      CANTP1_PTR_M3_C2_STD_0x5 = &(CAN_Msg[0]);



      /* ... perform loop-back if required */

      if (L4_MABX_P.Constant1_Value_bv > 0.5) {

        /* ... updating the used tx-clientbuffer */

        can_tp1_msg_update_all( CANTP1_TX_M3_C2_MCRCLT_STD_0X5->module,

          CANTP1_TX_M3_C2_MCRCLT_STD_0X5->queue );



        /* ... Read status and timestamp info perform loop-back (previous message) */

        can_tp1_tx_msg_read_loopback(CANTP1_TX_M3_C2_MCRCLT_STD_0X5,

          8,                           // datalen

          &(CAN_Msg[0]),

          CANTP1_RX_SPMSG_M3_C2_STD);



        /* Convert timestamp */

        if (CANTP1_TX_M3_C2_MCRCLT_STD_0X5->processed) {

          CANTP1_TX_M3_C2_MCRCLT_STD_0X5->timestamp =

            rtk_dsts_time_to_simtime_convert

            (CANTP1_TX_M3_C2_MCRCLT_STD_0X5->timestamp);

        }

      } else {

        /* ... Read status and timestamp info (previous message) */

        can_tp1_msg_read_from_dsmcr(CANTP1_TX_M3_C2_MCRCLT_STD_0X5);



        /* Convert timestamp */

        if (CANTP1_TX_M3_C2_MCRCLT_STD_0X5->processed) {

          CANTP1_TX_M3_C2_MCRCLT_STD_0X5->timestamp =

            rtk_dsts_time_to_simtime_convert

            (CANTP1_TX_M3_C2_MCRCLT_STD_0X5->timestamp);

        }

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (CANTP1_TX_M3_C2_MCRCLT_STD_0X5->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_l = (real_T)

          CANTP1_TX_M3_C2_MCRCLT_STD_0X5->processed;

        L4_MABX_B.SFunction1_o2_d = (real_T)

          CANTP1_TX_M3_C2_MCRCLT_STD_0X5->timestamp;

        L4_MABX_B.SFunction1_o3 = (real_T)

          CANTP1_TX_M3_C2_MCRCLT_STD_0X5->deltatime;

        L4_MABX_B.SFunction1_o4 = (real_T)

          CANTP1_TX_M3_C2_MCRCLT_STD_0X5->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;

        UInt32 i;



        /* Initialize the static message data to zero */

        for (i=0; i<8; i++ )

          CAN_Msg[i] = 0;



        /* ...... "SID" (0|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.SFunction1_o1_os ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "Source" (8|4, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.SFunction1_o2_ly ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000000F;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "Date" (16|16, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.SFunction1_o3_g ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte1;



        /* ...... "Time" (32|32, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.SFunction1_o4_hf - ( 0 ) ) /

          0.0001 + 0.5);

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte1;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte2;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte3;

      }



      delayTime = (Float32) L4_MABX_P.Constant_Value_g1 / (2000);



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0X5], 8, &(CAN_Msg[0]),

                       delayTime);

    }

  }



  /* End of Outputs for SubSystem: '<S1073>/Std_SystemTime_01' */



  /* Constant: '<S1064>/Byte1' */

  L4_MABX_B.VectorConcatenate[0] = L4_MABX_P.Byte1_Value_g;



  /* Constant: '<S1064>/Byte2' */

  L4_MABX_B.VectorConcatenate[1] = L4_MABX_P.Byte2_Value_h;



  /* Constant: '<S1064>/Byte3' */

  L4_MABX_B.VectorConcatenate[2] = L4_MABX_P.Byte3_Value_b;



  /* Constant: '<S1064>/Byte4' */

  L4_MABX_B.VectorConcatenate[3] = L4_MABX_P.Byte4_Value_a;



  /* Constant: '<S1064>/Byte5' */

  L4_MABX_B.VectorConcatenate[4] = L4_MABX_P.Byte5_Value_m;



  /* Constant: '<S1064>/Byte6' */

  L4_MABX_B.VectorConcatenate[5] = L4_MABX_P.Byte6_Value_b;



  /* Constant: '<S1064>/Byte7' */

  L4_MABX_B.VectorConcatenate[6] = L4_MABX_P.Byte7_Value_e;



  /* Constant: '<S1064>/Byte8' */

  L4_MABX_B.VectorConcatenate[7] = L4_MABX_P.Byte8_Value_av;



  /* DataTypeConversion: '<S1068>/Data Type Conversion' */

  for (i = 0; i < 8; i++) {

    L4_MABX_B.DataTypeConversion[i] = L4_MABX_B.VectorConcatenate[i];

  }



  /* End of DataTypeConversion: '<S1068>/Data Type Conversion' */



  /* UnitDelay: '<S865>/Unit Delay2' */

  L4_MABX_B.UnitDelay2 = L4_MABX_DW.UnitDelay2_DSTATE;



  /* Outputs for Triggered SubSystem: '<S1068>/CAN_TYPE1_TX_M1_C1' incorporates:

   *  TriggerPort: '<S1070>/Trigger'

   */

  zcEvent = (L4_MABX_B.UnitDelay2 &&

             (L4_MABX_PrevZCX.CAN_TYPE1_TX_M1_C1_Trig_ZCE_n != POS_ZCSIG));

  if (zcEvent) {

    /* S-Function (rti_commonblock): '<S1070>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "TX Message" Id:418184965 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18ECFF05]);



      /* Convert timestamp */

      if (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18ECFF05]->processed) {

        can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18ECFF05]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18ECFF05]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18ECFF05]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_o = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18ECFF05]->processed;

        L4_MABX_B.SFunction1_o2_a = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18ECFF05]->timestamp;

        L4_MABX_B.SFunction1_o3_c = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18ECFF05]->deltatime;

        L4_MABX_B.SFunction1_o4_l = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18ECFF05]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "Byte1" (0|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion[0] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "Byte2" (8|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion[1] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "Byte3" (16|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion[2] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "Byte4" (24|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion[3] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "Byte5" (32|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion[4] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "Byte6" (40|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion[5] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "Byte7" (48|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion[6] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "Byte8" (56|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion[7] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;

      }



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18ECFF05], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  L4_MABX_PrevZCX.CAN_TYPE1_TX_M1_C1_Trig_ZCE_n = L4_MABX_B.UnitDelay2;



  /* End of Outputs for SubSystem: '<S1068>/CAN_TYPE1_TX_M1_C1' */



  /* UnitDelay: '<S865>/Unit Delay1' */

  L4_MABX_B.UnitDelay1_f4 = L4_MABX_DW.UnitDelay1_DSTATE_mt;



  /* MultiPortSwitch: '<S865>/Multiport Switch' incorporates:

   *  Constant: '<S1066>/Byte1'

   *  Constant: '<S1066>/Byte2'

   *  Constant: '<S1066>/Byte3'

   *  Constant: '<S1066>/Byte4'

   *  Constant: '<S1066>/Byte5'

   *  Constant: '<S1066>/Byte6'

   *  Constant: '<S1066>/Byte7'

   *  Constant: '<S1066>/Byte8'

   *  Constant: '<S1067>/Byte1'

   *  Constant: '<S1067>/Byte2'

   *  Constant: '<S1067>/Byte3'

   *  Constant: '<S1067>/Byte4'

   *  Constant: '<S1067>/Byte5'

   *  Constant: '<S1067>/Byte6'

   *  Constant: '<S1067>/Byte7'

   *  Constant: '<S1067>/Byte8'

   */

  if (L4_MABX_B.UnitDelay1_f4 == 1) {

    L4_MABX_B.VectorConcatenate_p[7] = L4_MABX_P.Byte8_Value_a;

    L4_MABX_B.VectorConcatenate_p[6] = L4_MABX_P.Byte7_Value_o;

    L4_MABX_B.VectorConcatenate_p[5] = L4_MABX_P.Byte6_Value_n;

    L4_MABX_B.VectorConcatenate_p[4] = L4_MABX_P.Byte5_Value_n;

    L4_MABX_B.VectorConcatenate_p[3] = L4_MABX_P.Byte4_Value_g;

    L4_MABX_B.VectorConcatenate_p[2] = L4_MABX_P.Byte3_Value_a;

    L4_MABX_B.VectorConcatenate_p[1] = L4_MABX_P.Byte2_Value_i;

    L4_MABX_B.VectorConcatenate_p[0] = L4_MABX_P.Byte1_Value_h;

    for (i = 0; i < 8; i++) {

      L4_MABX_B.MultiportSwitch_l[i] = L4_MABX_B.VectorConcatenate_p[i];

    }

  } else {

    L4_MABX_B.VectorConcatenate_n[7] = L4_MABX_P.Byte8_Value;

    L4_MABX_B.VectorConcatenate_n[6] = L4_MABX_P.Byte7_Value;

    L4_MABX_B.VectorConcatenate_n[5] = L4_MABX_P.Byte6_Value;

    L4_MABX_B.VectorConcatenate_n[4] = L4_MABX_P.Byte5_Value;

    L4_MABX_B.VectorConcatenate_n[3] = L4_MABX_P.Byte4_Value;

    L4_MABX_B.VectorConcatenate_n[2] = L4_MABX_P.Byte3_Value;

    L4_MABX_B.VectorConcatenate_n[1] = L4_MABX_P.Byte2_Value;

    L4_MABX_B.VectorConcatenate_n[0] = L4_MABX_P.Byte1_Value;

    for (i = 0; i < 8; i++) {

      L4_MABX_B.MultiportSwitch_l[i] = L4_MABX_B.VectorConcatenate_n[i];

    }

  }



  /* End of MultiPortSwitch: '<S865>/Multiport Switch' */



  /* DataTypeConversion: '<S1069>/Data Type Conversion' */

  for (i = 0; i < 8; i++) {

    L4_MABX_B.DataTypeConversion_d[i] = L4_MABX_B.MultiportSwitch_l[i];

  }



  /* End of DataTypeConversion: '<S1069>/Data Type Conversion' */



  /* UnitDelay: '<S865>/Unit Delay3' */

  L4_MABX_B.UnitDelay3 = L4_MABX_DW.UnitDelay3_DSTATE;



  /* Outputs for Triggered SubSystem: '<S1069>/CAN_TYPE1_TX_M1_C1' incorporates:

   *  TriggerPort: '<S1071>/Trigger'

   */

  zcEvent = (L4_MABX_B.UnitDelay3 &&

             (L4_MABX_PrevZCX.CAN_TYPE1_TX_M1_C1_Trig_ZCE != POS_ZCSIG));

  if (zcEvent) {

    /* S-Function (rti_commonblock): '<S1071>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "TX Message" Id:418119429 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18EBFF05]);



      /* Convert timestamp */

      if (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18EBFF05]->processed) {

        can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18EBFF05]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18EBFF05]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18EBFF05]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_j = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18EBFF05]->processed;

        L4_MABX_B.SFunction1_o2_e = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18EBFF05]->timestamp;

        L4_MABX_B.SFunction1_o3_l = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18EBFF05]->deltatime;

        L4_MABX_B.SFunction1_o4_a = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18EBFF05]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "Byte1" (0|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion_d[0] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "Byte2" (8|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion_d[1] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "Byte3" (16|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion_d[2] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "Byte4" (24|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion_d[3] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "Byte5" (32|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion_d[4] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "Byte6" (40|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion_d[5] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "Byte7" (48|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion_d[6] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "Byte8" (56|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion_d[7] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;

      }



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18EBFF05], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  L4_MABX_PrevZCX.CAN_TYPE1_TX_M1_C1_Trig_ZCE = L4_MABX_B.UnitDelay3;



  /* End of Outputs for SubSystem: '<S1069>/CAN_TYPE1_TX_M1_C1' */



  /* Chart: '<S865>/Chart' incorporates:

   *  Constant: '<S865>/Constant1'

   */

  if (L4_MABX_DW.temporalCounter_i1_m < 255U) {

    L4_MABX_DW.temporalCounter_i1_m++;

  }



  /* Gateway: OUTPUTS_PIC_KW/CAN_Out_PIC_KW/CAN_TX_BAM/Chart */

  /* During: OUTPUTS_PIC_KW/CAN_Out_PIC_KW/CAN_TX_BAM/Chart */

  if (L4_MABX_DW.is_active_c4_SUB_ECU_L4_MABX_HW == 0U) {

    /* Entry: OUTPUTS_PIC_KW/CAN_Out_PIC_KW/CAN_TX_BAM/Chart */

    L4_MABX_DW.is_active_c4_SUB_ECU_L4_MABX_HW = 1U;



    /* Entry Internal: OUTPUTS_PIC_KW/CAN_Out_PIC_KW/CAN_TX_BAM/Chart */

    /* Transition: '<S1065>:4' */

    L4_MABX_DW.is_c4_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_Init_l;



    /* Entry 'Init': '<S1065>:1' */

    L4_MABX_B.State = 0U;

    L4_MABX_B.enTPCM = false;

    L4_MABX_B.enTPDT = false;

    L4_MABX_B.TPCM_ts_Prev = L4_MABX_B.SFunction1_o2_a;

    L4_MABX_B.TPDT_ts_Prev = L4_MABX_B.SFunction1_o2_e;

    L4_MABX_B.TPDT_count = 0U;

  } else {

    switch (L4_MABX_DW.is_c4_SUB_ECU_L4_MABX_HW_Interf) {

     case L4_MABX_IN_CheckPacketCount:

      L4_MABX_B.State = 6U;



      /* During 'CheckPacketCount': '<S1065>:11' */

      if (L4_MABX_B.TPDT_count <= L4_MABX_P.Constant1_Value_jf) {

        /* Transition: '<S1065>:18' */

        L4_MABX_DW.is_c4_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_SendTPDT;

        L4_MABX_DW.temporalCounter_i1_m = 0U;



        /* Entry 'SendTPDT': '<S1065>:6' */

        L4_MABX_B.State = 4U;

        L4_MABX_B.enTPDT = true;

      } else {

        /* Transition: '<S1065>:19' */

        L4_MABX_DW.is_c4_SUB_ECU_L4_MABX_HW_Interf =

          L4_MABX_IN_WaitForNextPeriod;

        L4_MABX_DW.temporalCounter_i1_m = 0U;



        /* Entry 'WaitForNextPeriod': '<S1065>:17' */

        L4_MABX_B.State = 7U;

      }

      break;



     case L4_MABX_IN_Init_l:

      /* During 'Init': '<S1065>:1' */

      /* Transition: '<S1065>:9' */

      L4_MABX_DW.is_c4_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_StartMsg;



      /* Entry 'StartMsg': '<S1065>:30' */

      L4_MABX_B.State = 1U;

      L4_MABX_B.TPDT_count = 1U;

      break;



     case L4_MABX_IN_InterframeDelay:

      L4_MABX_B.State = 3U;



      /* During 'InterframeDelay': '<S1065>:7' */

      if (L4_MABX_DW.temporalCounter_i1_m >= 5U) {

        /* Transition: '<S1065>:10' */

        L4_MABX_DW.is_c4_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_SendTPDT;

        L4_MABX_DW.temporalCounter_i1_m = 0U;



        /* Entry 'SendTPDT': '<S1065>:6' */

        L4_MABX_B.State = 4U;

        L4_MABX_B.enTPDT = true;

      }

      break;



     case L4_MABX_IN_InterframeDelay1:

      L4_MABX_B.State = 5U;



      /* During 'InterframeDelay1': '<S1065>:12' */

      if (L4_MABX_DW.temporalCounter_i1_m >= 5U) {

        /* Transition: '<S1065>:14' */

        L4_MABX_DW.is_c4_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_CheckPacketCount;



        /* Entry 'CheckPacketCount': '<S1065>:11' */

        L4_MABX_B.State = 6U;

        i = (int32_T)(L4_MABX_B.TPDT_count + 1U);

        if ((uint32_T)i > 255U) {

          i = 255;

        }



        L4_MABX_B.TPDT_count = (uint8_T)i;

      }

      break;



     case L4_MABX_IN_SendTPCM:

      L4_MABX_B.State = 2U;



      /* During 'SendTPCM': '<S1065>:5' */

      if (L4_MABX_DW.temporalCounter_i1_m >= 1U) {

        /* Transition: '<S1065>:8' */

        L4_MABX_DW.is_c4_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_InterframeDelay;

        L4_MABX_DW.temporalCounter_i1_m = 0U;



        /* Entry 'InterframeDelay': '<S1065>:7' */

        L4_MABX_B.State = 3U;

        L4_MABX_B.enTPCM = false;

        L4_MABX_B.TPCM_ts_Prev = L4_MABX_B.SFunction1_o2_a;

      }

      break;



     case L4_MABX_IN_SendTPDT:

      L4_MABX_B.State = 4U;



      /* During 'SendTPDT': '<S1065>:6' */

      if (L4_MABX_DW.temporalCounter_i1_m >= 1U) {

        /* Transition: '<S1065>:13' */

        L4_MABX_DW.is_c4_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_InterframeDelay1;

        L4_MABX_DW.temporalCounter_i1_m = 0U;



        /* Entry 'InterframeDelay1': '<S1065>:12' */

        L4_MABX_B.State = 5U;

        L4_MABX_B.enTPDT = false;

        L4_MABX_B.TPDT_ts_Prev = L4_MABX_B.SFunction1_o2_e;

      }

      break;



     case L4_MABX_IN_StartMsg:

      /* During 'StartMsg': '<S1065>:30' */

      /* Transition: '<S1065>:31' */

      L4_MABX_DW.is_c4_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_SendTPCM;

      L4_MABX_DW.temporalCounter_i1_m = 0U;



      /* Entry 'SendTPCM': '<S1065>:5' */

      L4_MABX_B.State = 2U;

      L4_MABX_B.enTPCM = true;

      break;



     default:

      L4_MABX_B.State = 7U;



      /* During 'WaitForNextPeriod': '<S1065>:17' */

      if (L4_MABX_DW.temporalCounter_i1_m >= 185U) {

        /* Transition: '<S1065>:20' */

        L4_MABX_DW.is_c4_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_StartMsg;



        /* Entry 'StartMsg': '<S1065>:30' */

        L4_MABX_B.State = 1U;

        L4_MABX_B.TPDT_count = 1U;

      }

      break;

    }

  }



  /* End of Chart: '<S865>/Chart' */



  /* RateTransition: '<S1083>/TmpRTBAtFlashOutport1' */

  if (L4_MABX_M->Timing.RateInteraction.TID0_3 == 1) {

    L4_MABX_B.TmpRTBAtFlashOutport1 = L4_MABX_DW.TmpRTBAtFlashOutport1_Buffer0;

  }



  /* End of RateTransition: '<S1083>/TmpRTBAtFlashOutport1' */



  /* RelationalOperator: '<S1091>/Operator' incorporates:

   *  Constant: '<S1083>/Manual Ready'

   */

  L4_MABX_B.Operator_cd = (L4_MABX_P.ManualReady_Value == SupervisorMode);



  /* Logic: '<S1083>/AND3' */

  L4_MABX_B.AND3 = ((L4_MABX_B.TmpRTBAtFlashOutport1 != 0.0) &&

                    L4_MABX_B.Operator_cd);



  /* Logic: '<S1083>/NOT2' */

  L4_MABX_B.NOT2 = !L4_MABX_B.Operator_cd;



  /* Logic: '<S1083>/OR1' */

  L4_MABX_B.OR1_e = (L4_MABX_B.AND3 || L4_MABX_B.NOT2);



  /* Logic: '<S1083>/NOT1' */

  L4_MABX_B.NOT1 = !L4_MABX_B.AutonomousEnabled_d;



  /* RelationalOperator: '<S1092>/Operator' incorporates:

   *  Constant: '<S1083>/Constant2'

   */

  L4_MABX_B.Operator_fz = (L4_MABX_P.Constant2_Value_mw == MABX_Mode);



  /* Logic: '<S1083>/NOT' */

  L4_MABX_B.NOT_o = !L4_MABX_B.Operator_fz;



  /* Logic: '<S1083>/AND1' */

  L4_MABX_B.AND1 = (L4_MABX_B.OR1_e && EnableSw && L4_MABX_B.NOT1 &&

                    L4_MABX_B.NOT_o);



  /* S-Function (rti_commonblock): '<S1076>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* write output state value to digital output channel 1 on port 1 */

  dio_tp4_digout_write(DIO_TP4_1_MODULE_ADDR, 1, DIO_TP4_MASK_CH1, (UInt16)

                       (L4_MABX_B.AND1 << 0));



  /* Logic: '<S1083>/AND' */

  L4_MABX_B.AND_m = (L4_MABX_B.AutonomousEnabled_d &&

                     (L4_MABX_B.TmpRTBAtFlashOutport1 != 0.0));



  /* Logic: '<S1083>/OR' */

  L4_MABX_B.OR = (L4_MABX_B.AND_m || AutonomousOutputEnabled);



  /* Logic: '<S1083>/AND2' */

  L4_MABX_B.AND2_d = (L4_MABX_B.NOT_o && L4_MABX_B.OR);



  /* S-Function (rti_commonblock): '<S1077>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* write output state value to digital output channel 2 on port 1 */

  dio_tp4_digout_write(DIO_TP4_1_MODULE_ADDR, 1, DIO_TP4_MASK_CH2, (UInt16)

                       (L4_MABX_B.AND2_d << 1));



  /* S-Function (rti_commonblock): '<S1078>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* write output state value to digital output channel 6 on port 2 */

  dio_tp4_digout_write(DIO_TP4_1_MODULE_ADDR, 2, DIO_TP4_MASK_CH6, (UInt16)

                       (L4_MABX_B.Operator_fz << 5));



  /* Logic: '<S1081>/Logical Operator' */

  L4_MABX_B.LogicalOperator_n = !AutonomousOutputEnabled;



  /* Outputs for Atomic SubSystem: '<S1081>/If_Then_Else4' */



  /* Constant: '<S1081>/APTC_PEDAL_A_PWM_FREQ_HZ_APV' */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator_n,

                       L4_MABX_B.Pedal_1_pwm_freq_raw_value,

                       L4_MABX_P.APTC_PEDAL_A_PWM_FREQ_HZ_APV_Va,

                       &L4_MABX_B.If_Then_Else4);



  /* End of Outputs for SubSystem: '<S1081>/If_Then_Else4' */



  /* MinMax: '<S856>/MinMax' incorporates:

   *  Constant: '<S856>/Constant2'

   */

  DeltaTime = L4_MABX_B.If_Then_Else4.Switch;

  PositionFinalLimited = L4_MABX_P.Constant2_Value_mi;

  if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax_n = PositionFinalLimited;



  /* End of MinMax: '<S856>/MinMax' */



  /* DataTypeConversion: '<S856>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1 = L4_MABX_B.MinMax_n;



  /* Product: '<S856>/Divide' incorporates:

   *  Constant: '<S856>/Constant3'

   */

  L4_MABX_B.Divide_l = L4_MABX_P.Constant3_Value_c /

    L4_MABX_B.DataTypeConversion1;



  /* DataTypeConversion: '<S856>/Data Type Conversion5' */

  L4_MABX_B.PWMOut_P2C1_Period = L4_MABX_B.Divide_l;



  /* Lookup_n-D: '<S1081>/1-D Lookup Table2' */

  L4_MABX_B.PedalPWMA_DC_out = look1_binlcapw(L4_MABX_B.If_Then_Else_f.Switch,

    L4_MABX_P.uDLookupTable2_bp01Data, L4_MABX_P.uDLookupTable2_tableData, 1U);



  /* Outputs for Atomic SubSystem: '<S1081>/If_Then_Else1' */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator_n,

                       L4_MABX_B.Pedal_1_pwm_dc_raw_value,

                       L4_MABX_B.PedalPWMA_DC_out, &L4_MABX_B.If_Then_Else1_l);



  /* End of Outputs for SubSystem: '<S1081>/If_Then_Else1' */



  /* Gain: '<S856>/Gain1' */

  L4_MABX_B.Gain1_a = L4_MABX_P.Gain1_Gain_oe * L4_MABX_B.If_Then_Else1_l.Switch;



  /* DataTypeConversion: '<S856>/Data Type Conversion6' */

  L4_MABX_B.PWMOut_P2C1_DC = L4_MABX_B.Gain1_a;



  /* S-Function (rti_commonblock): '<S1079>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* write PWM Period and DutyCycle for output channel 1 on port 2 */

  dio_tp4_pwm_update(DIO_TP4_1_MODULE_ADDR , 2, 1, (real_T)

                     L4_MABX_B.PWMOut_P2C1_Period, (real_T)

                     L4_MABX_B.PWMOut_P2C1_DC);



  /* Outputs for Atomic SubSystem: '<S1081>/If_Then_Else5' */



  /* Constant: '<S1081>/APTC_PEDAL_B_PWM_FREQ_HZ_APV' */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator_n,

                       L4_MABX_B.Pedal_2_pwm_freq_raw_value,

                       L4_MABX_P.APTC_PEDAL_B_PWM_FREQ_HZ_APV_Va,

                       &L4_MABX_B.If_Then_Else5);



  /* End of Outputs for SubSystem: '<S1081>/If_Then_Else5' */



  /* MinMax: '<S856>/MinMax1' incorporates:

   *  Constant: '<S856>/Constant4'

   */

  DeltaTime = L4_MABX_B.If_Then_Else5.Switch;

  PositionFinalLimited = L4_MABX_P.Constant4_Value_p;

  if ((DeltaTime > PositionFinalLimited) || rtIsNaN(PositionFinalLimited)) {

    PositionFinalLimited = DeltaTime;

  }



  L4_MABX_B.MinMax1_j = PositionFinalLimited;



  /* End of MinMax: '<S856>/MinMax1' */



  /* DataTypeConversion: '<S856>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_f = L4_MABX_B.MinMax1_j;



  /* Product: '<S856>/Divide1' incorporates:

   *  Constant: '<S856>/Constant1'

   */

  L4_MABX_B.Divide1 = L4_MABX_P.Constant1_Value_lv /

    L4_MABX_B.DataTypeConversion2_f;



  /* DataTypeConversion: '<S856>/Data Type Conversion9' */

  L4_MABX_B.PWMOut_P2C2_Period = L4_MABX_B.Divide1;



  /* Lookup_n-D: '<S1081>/1-D Lookup Table3' */

  L4_MABX_B.PedalPWMB_DC_out = look1_binlcapw(L4_MABX_B.If_Then_Else_f.Switch,

    L4_MABX_P.uDLookupTable3_bp01Data, L4_MABX_P.uDLookupTable3_tableData, 1U);



  /* Outputs for Atomic SubSystem: '<S1081>/If_Then_Else2' */

  L4_MABX_If_Then_Else(L4_MABX_B.LogicalOperator_n,

                       L4_MABX_B.Pedal_2_pwm_dc_raw_value,

                       L4_MABX_B.PedalPWMB_DC_out, &L4_MABX_B.If_Then_Else2_m);



  /* End of Outputs for SubSystem: '<S1081>/If_Then_Else2' */



  /* Gain: '<S856>/Gain' */

  L4_MABX_B.Gain_h = L4_MABX_P.Gain_Gain_d * L4_MABX_B.If_Then_Else2_m.Switch;



  /* DataTypeConversion: '<S856>/Data Type Conversion10' */

  L4_MABX_B.PWMOut_P2C2_DC = L4_MABX_B.Gain_h;



  /* S-Function (rti_commonblock): '<S1080>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* write PWM Period and DutyCycle for output channel 2 on port 2 */

  dio_tp4_pwm_update(DIO_TP4_1_MODULE_ADDR , 2, 2, (real_T)

                     L4_MABX_B.PWMOut_P2C2_Period, (real_T)

                     L4_MABX_B.PWMOut_P2C2_DC);



  /* S-Function (rti_commonblock): '<S745>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* Gain: '<S422>/ShifterControlDC' */

  L4_MABX_B.ShiftControlDC = L4_MABX_P.ShifterControlDC_Gain *

    L4_MABX_B.SFunction1_o2_i;



  /* RelationalOperator: '<S1082>/Relational Operator' incorporates:

   *  Constant: '<S1082>/Constant'

   */

  L4_MABX_B.RelationalOperator_d = (L4_MABX_B.ShiftControlDC >=

    L4_MABX_P.Constant_Value_lg);



  /* RelationalOperator: '<S1082>/Relational Operator1' incorporates:

   *  Constant: '<S1082>/Constant1'

   */

  L4_MABX_B.RelationalOperator1_o = (L4_MABX_B.ShiftControlDC <=

    L4_MABX_P.Constant1_Value_g5);



  /* Logic: '<S1082>/Logical Operator' */

  L4_MABX_B.LogicalOperator_e = (L4_MABX_B.RelationalOperator_d &&

    L4_MABX_B.RelationalOperator1_o);



  /* RelationalOperator: '<S1088>/Compare' incorporates:

   *  Constant: '<S1088>/Constant'

   */

  L4_MABX_B.Compare_pu = (L4_MABX_B.SPN524_TransSelectedGear ==

    L4_MABX_P.Constant_Value_af);



  /* RelationalOperator: '<S1089>/Compare' incorporates:

   *  Constant: '<S1089>/Constant'

   */

  L4_MABX_B.Compare_j = (L4_MABX_B.SPN523_TransCurrentGear ==

    L4_MABX_P.Constant_Value_j1);



  /* Logic: '<S1082>/Logical Operator1' */

  L4_MABX_B.LogicalOperator1_p = (L4_MABX_B.Compare_pu && L4_MABX_B.Compare_j);



  /* Outputs for Atomic SubSystem: '<S1082>/If_Then_Else' */



  /* Constant: '<S1082>/F_ALLOW_ETC2_FOR_NEUTRAL_OUTPUT_APV' incorporates:

   *  Constant: '<S1082>/Constant2'

   */

  L4_MABX_If_Then_Else3(L4_MABX_P.F_ALLOW_ETC2_FOR_NEUTRAL_OUTPUT,

                        L4_MABX_B.LogicalOperator1_p,

                        L4_MABX_P.Constant2_Value_f, &L4_MABX_B.If_Then_Else_e);



  /* End of Outputs for SubSystem: '<S1082>/If_Then_Else' */



  /* Logic: '<S1082>/Logical Operator2' */

  L4_MABX_B.Neutral = (L4_MABX_B.LogicalOperator_e ||

                       L4_MABX_B.If_Then_Else_e.Switch);



  /* Logic: '<S856>/Logical Operator' */

  L4_MABX_B.LogicalOperator_bx = !L4_MABX_B.Neutral;



  /* Outputs for Enabled SubSystem: '<S579>/GNSSDOPs_011' incorporates:

   *  EnablePort: '<S580>/Enable'

   */

  /* Constant: '<S447>/Constant' */

  if (L4_MABX_P.Constant_Value_by > 0.0) {

    /* S-Function (rti_commonblock): '<S580>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "GNSSDOPs_01" Id:435815168 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x19FA0300].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x19FA0300].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o7_l3 = 1.0;

        L4_MABX_B.SFunction1_o8_es = (real_T)

          can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x19FA0300].timestamp;

        L4_MABX_B.SFunction1_o9_gd = (real_T)

          can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x19FA0300].deltatime;

        CAN_Msg = can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x19FA0300].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "SID" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_hs = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SetMode" (8|3, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x00000007;

            L4_MABX_B.SFunction1_o2_d0 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "OpMode" (11|3, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 3;

            CAN_Sgn.UnsignedSgn &= 0x00000007;

            L4_MABX_B.SFunction1_o3_o4 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "HDOP_" (16|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[3];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o4_j0 = 0.01 * ( ((real_T) CAN_Sgn.SignedSgn) );



            /* ...... "VDOP" (32|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o5_nf = 0.01 * ( ((real_T) CAN_Sgn.SignedSgn) );



            /* ...... "TDOP" (48|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[7];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o6_g4y = 0.01 * ( ((real_T) CAN_Sgn.SignedSgn) );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o7_l3 = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S579>/GNSSDOPs_011' */



  /* DataTypeConversion: '<S579>/Data Type Conversion8' */

  L4_MABX_B.RX_status_h = (L4_MABX_B.SFunction1_o7_l3 != 0.0);



  /* Outputs for Enabled SubSystem: '<S579>/GNSSDOPs_1' incorporates:

   *  EnablePort: '<S581>/Enable'

   */

  /* Constant: '<S447>/Constant' */

  if (L4_MABX_P.Constant_Value_by > 0.0) {

    /* S-Function (rti_commonblock): '<S581>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "GNSSDOPs_01" Id:435815169 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x19FA0301].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x19FA0301].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o7_ev = 1.0;

        L4_MABX_B.SFunction1_o8_lx = (real_T)

          can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x19FA0301].timestamp;

        L4_MABX_B.SFunction1_o9_d = (real_T)

          can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x19FA0301].deltatime;

        CAN_Msg = can_type1_M2_C2_XTD[CANTP1_M2_C2_RXSRVC_XTD_0x19FA0301].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "SID" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_lx = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SetMode" (8|3, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x00000007;

            L4_MABX_B.SFunction1_o2_ad5 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "OpMode" (11|3, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 3;

            CAN_Sgn.UnsignedSgn &= 0x00000007;

            L4_MABX_B.SFunction1_o3_g5 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "HDOP_" (16|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[3];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o4_iv = 0.01 * ( ((real_T) CAN_Sgn.SignedSgn) );



            /* ...... "VDOP" (32|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o5_lw = 0.01 * ( ((real_T) CAN_Sgn.SignedSgn) );



            /* ...... "TDOP" (48|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[7];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o6_nk = 0.01 * ( ((real_T) CAN_Sgn.SignedSgn) );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o7_ev = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S579>/GNSSDOPs_1' */



  /* Switch: '<S579>/Switch' */

  if (L4_MABX_B.RX_status_h) {

    L4_MABX_B.HDOP_ = L4_MABX_B.SFunction1_o4_j0;

  } else {

    L4_MABX_B.HDOP_ = L4_MABX_B.SFunction1_o4_iv;

  }



  /* Outputs for Atomic SubSystem: '<S65>/Task_20ms' */

  /* RateTransition: '<S401>/TmpRTBAtCheckHDOPInport1' */

  if (L4_MABX_M->Timing.RateInteraction.TID0_1 == 1) {

    L4_MABX_B.HDOP__f = L4_MABX_B.HDOP_;

    L4_MABX_B.FrontAxleSpeed_d = L4_MABX_B.SFunction1_o1_gd;

    L4_MABX_B.FrontAxleSpeed_dv = L4_MABX_B.SFunction1_o1_gd;

    L4_MABX_B.FrontAxleSpeed_dvq = L4_MABX_B.SFunction1_o1_gd;

    L4_MABX_B.TmpRTBAtVehHeadingInport1 = YawRate;

  }



  /* End of RateTransition: '<S401>/TmpRTBAtCheckHDOPInport1' */

  /* End of Outputs for SubSystem: '<S65>/Task_20ms' */



  /* Switch: '<S403>/Switch2' incorporates:

   *  Constant: '<S403>/No Data'

   *  Switch: '<S403>/Switch6'

   *  Switch: '<S403>/Switch7'

   *  Switch: '<S403>/Switch8'

   */

  if (RTMapsOk) {

    /* Gain: '<S403>/m//s_to_km//h' */

    L4_MABX_B.ms_to_kmh = L4_MABX_P.ms_to_kmh_Gain *

      L4_MABX_B.Decoder_o1.CurrentVelocity;

    CurrentVelocity_kph = L4_MABX_B.ms_to_kmh;



    /* Gain: '<S403>/for_logging4' */

    L4_MABX_B.for_logging4 = L4_MABX_P.for_logging4_Gain *

      L4_MABX_B.Decoder_o1.GPS_X;

    GPS_X = L4_MABX_B.for_logging4;



    /* Gain: '<S403>/for_logging5' */

    L4_MABX_B.for_logging5 = L4_MABX_P.for_logging5_Gain *

      L4_MABX_B.Decoder_o1.GPS_Y;

    GPS_Y = L4_MABX_B.for_logging5;



    /* Gain: '<S403>/for_logging6' */

    L4_MABX_B.for_logging6 = L4_MABX_P.for_logging6_Gain *

      L4_MABX_B.Decoder_o1.GPS_Time;

    GPS_Time = L4_MABX_B.for_logging6;

  } else {

    CurrentVelocity_kph = L4_MABX_P.NoData_Value;

    GPS_X = L4_MABX_P.NoData_Value;

    GPS_Y = L4_MABX_P.NoData_Value;

    GPS_Time = L4_MABX_P.NoData_Value;

  }



  /* End of Switch: '<S403>/Switch2' */



  /* S-Function (rti_commonblock): '<S414>/S-Function1' */



  /* This comment workarounds a code generation problem */



  /* End of Outputs for S-Function (rti_commonblock): '<S414>/S-Function1' */



  /* S-Function (rti_commonblock): '<S420>/S-Function1' */



  /* This comment workarounds a code generation problem */



  /* End of Outputs for S-Function (rti_commonblock): '<S420>/S-Function1' */



  /* S-Function (rti_commonblock): '<S405>/TRC Exclusion' */

  /* This comment workarounds a code generation problem */



  /* S-Function (rti_commonblock): '<S406>/TRC Exclusion' */

  /* This comment workarounds a code generation problem */



  /* UnitDelay: '<S3>/Unit_Delay' */

  L4_MABX_B.DesSteeringAngle = L4_MABX_DW.Unit_Delay_1_DSTATE;

  L4_MABX_B.Stanley_axleAngle2 = L4_MABX_DW.Unit_Delay_10_DSTATE;

  L4_MABX_B.DriversDemandEngPercentTorque = L4_MABX_DW.Unit_Delay_100_DSTATE;

  L4_MABX_B.SPN514_NominalFrictionPercent_g = L4_MABX_DW.Unit_Delay_101_DSTATE;

  L4_MABX_B.SPN2978_EstEngParasiticLosses_m = L4_MABX_DW.Unit_Delay_102_DSTATE;

  L4_MABX_B.SPN1760_GrossCombinationVehic_h = L4_MABX_DW.Unit_Delay_103_DSTATE;

  L4_MABX_B.ACCDistanceAlertSignal_o = L4_MABX_DW.Unit_Delay_104_DSTATE;

  L4_MABX_B.ForwardCollisionWarning_c = L4_MABX_DW.Unit_Delay_105_DSTATE;

  L4_MABX_B.SPN544_EngineReferenceTorque_g = L4_MABX_DW.Unit_Delay_106_DSTATE;

  L4_MABX_B.ROPEngCtrlActive = L4_MABX_DW.Unit_Delay_107_DSTATE;

  L4_MABX_B.ROPBrakeCtrlActive = L4_MABX_DW.Unit_Delay_108_DSTATE;

  L4_MABX_B.YCEngCtrlActive = L4_MABX_DW.Unit_Delay_109_DSTATE;

  L4_MABX_B.DesSteeringAngleTerm = L4_MABX_DW.Unit_Delay_11_DSTATE;

  L4_MABX_B.YCBrakeCtrlActive = L4_MABX_DW.Unit_Delay_110_DSTATE;

  L4_MABX_B.SPN1807_SteeringWheelAngle = L4_MABX_DW.Unit_Delay_111_DSTATE;

  L4_MABX_B.SPN1808_YawRate = L4_MABX_DW.Unit_Delay_112_DSTATE;

  L4_MABX_B.SPN1810_LongitudinalAcceleratio = L4_MABX_DW.Unit_Delay_113_DSTATE;

  L4_MABX_B.SteerWheelTurnCounter = L4_MABX_DW.Unit_Delay_114_DSTATE;

  L4_MABX_B.SteerWheelAngleSensorType = L4_MABX_DW.Unit_Delay_115_DSTATE;

  L4_MABX_B.LateralAcceleration = L4_MABX_DW.Unit_Delay_116_DSTATE;

  L4_MABX_B.BarometricPress = L4_MABX_DW.Unit_Delay_117_DSTATE;

  L4_MABX_B.AmbientAirTemp = L4_MABX_DW.Unit_Delay_118_DSTATE;

  L4_MABX_B.F_Truck1571_VIN_Match = L4_MABX_DW.Unit_Delay_119_DSTATE;

  L4_MABX_B.DesSteeringDistTerm = L4_MABX_DW.Unit_Delay_12_DSTATE;

  L4_MABX_B.F_Truck166_VIN_Match = L4_MABX_DW.Unit_Delay_120_DSTATE;

  L4_MABX_B.PitchAngleExRange_m = L4_MABX_DW.Unit_Delay_121_DSTATE;

  L4_MABX_B.PX2_LanePosEstPosition = L4_MABX_DW.Unit_Delay_122_DSTATE;

  L4_MABX_B.PX2_LanePosEstAngle = L4_MABX_DW.Unit_Delay_123_DSTATE;

  L4_MABX_B.PX2_LanePosEstNumPoints = L4_MABX_DW.Unit_Delay_124_DSTATE;

  L4_MABX_B.Latitude__c = L4_MABX_DW.Unit_Delay_125_DSTATE;

  L4_MABX_B.Longitude__m = L4_MABX_DW.Unit_Delay_126_DSTATE;

  L4_MABX_B.HDOP__o = L4_MABX_DW.Unit_Delay_127_DSTATE;

  L4_MABX_B.XPRControlMode_d = L4_MABX_DW.Unit_Delay_128_DSTATE;

  L4_MABX_B.XPRErrorState_d = L4_MABX_DW.Unit_Delay_129_DSTATE;

  L4_MABX_B.numLanePoints = L4_MABX_DW.Unit_Delay_13_DSTATE;

  L4_MABX_B.PressureP1_a = L4_MABX_DW.Unit_Delay_130_DSTATE;

  L4_MABX_B.PressureP4_h = L4_MABX_DW.Unit_Delay_131_DSTATE;

  L4_MABX_B.PressureP21_b = L4_MABX_DW.Unit_Delay_132_DSTATE;

  L4_MABX_B.PressureP22_e = L4_MABX_DW.Unit_Delay_133_DSTATE;

  L4_MABX_B.PressureP42_n = L4_MABX_DW.Unit_Delay_134_DSTATE;

  L4_MABX_B.ReAX_ActualHandwheelPos_p = L4_MABX_DW.Unit_Delay_135_DSTATE;

  L4_MABX_B.ReAX_EchoedSteerWheelPos_p = L4_MABX_DW.Unit_Delay_136_DSTATE;

  L4_MABX_B.SystemsOk_a = L4_MABX_DW.Unit_Delay_137_DSTATE;

  L4_MABX_B.SupervisorMode_l = L4_MABX_DW.Unit_Delay_138_DSTATE;

  L4_MABX_B.CurrentAzimuth_rad_k = L4_MABX_DW.Unit_Delay_139_DSTATE;

  L4_MABX_B.rawPositionError = L4_MABX_DW.Unit_Delay_14_DSTATE;

  L4_MABX_B.TargetAzimuth_rad_i = L4_MABX_DW.Unit_Delay_140_DSTATE;

  L4_MABX_B.CurrentVelocity_kph_k = L4_MABX_DW.Unit_Delay_141_DSTATE;

  L4_MABX_B.TargetVelocity_kph_m = L4_MABX_DW.Unit_Delay_142_DSTATE;

  L4_MABX_B.Curvature_a = L4_MABX_DW.Unit_Delay_143_DSTATE;

  L4_MABX_B.CrosstrackError_n = L4_MABX_DW.Unit_Delay_144_DSTATE;

  L4_MABX_B.slewedPosError = L4_MABX_DW.Unit_Delay_15_DSTATE;

  L4_MABX_B.previewSteeringAngle = L4_MABX_DW.Unit_Delay_16_DSTATE;

  L4_MABX_B.APTC_Pedal_torque_dem_value = L4_MABX_DW.Unit_Delay_17_DSTATE;

  L4_MABX_B.APTC_arb_pedal_low_idl_sw = L4_MABX_DW.Unit_Delay_18_DSTATE;

  L4_MABX_B.APTC_arb_pedal_position = L4_MABX_DW.Unit_Delay_19_DSTATE;

  L4_MABX_B.DesSteeringPID_Dterm = L4_MABX_DW.Unit_Delay_2_DSTATE;

  L4_MABX_B.signal1 = L4_MABX_DW.Unit_Delay_20_DSTATE;

  L4_MABX_B.PID_output = L4_MABX_DW.Unit_Delay_21_DSTATE;

  L4_MABX_B.PID_output_unlim = L4_MABX_DW.Unit_Delay_22_DSTATE;

  L4_MABX_B.PID_control_error = L4_MABX_DW.Unit_Delay_23_DSTATE;

  L4_MABX_B.PID_p_term = L4_MABX_DW.Unit_Delay_24_DSTATE;

  L4_MABX_B.PID_i_term = L4_MABX_DW.Unit_Delay_25_DSTATE;

  L4_MABX_B.PID_d_term = L4_MABX_DW.Unit_Delay_26_DSTATE;

  L4_MABX_B.PID_hold_i_term_f = L4_MABX_DW.Unit_Delay_27_DSTATE;

  L4_MABX_B.ThrottlePID_Y = L4_MABX_DW.Unit_Delay_28_DSTATE;

  L4_MABX_B.EngineSpeedTarget_Y = L4_MABX_DW.Unit_Delay_29_DSTATE;

  L4_MABX_B.DesSteeringPID_Iterm = L4_MABX_DW.Unit_Delay_3_DSTATE;

  L4_MABX_B.F_Ignition_relay_command = L4_MABX_DW.Unit_Delay_30_DSTATE;

  L4_MABX_B.F_Inverter_relay_command = L4_MABX_DW.Unit_Delay_31_DSTATE;

  L4_MABX_B.F_MABX_relay_command = L4_MABX_DW.Unit_Delay_32_DSTATE;

  L4_MABX_B.F_Sensor_relay_command = L4_MABX_DW.Unit_Delay_33_DSTATE;

  L4_MABX_B.BrkPedArbBrakeSwitch = L4_MABX_DW.Unit_Delay_34_DSTATE;

  L4_MABX_B.Accel_rate_ms2 = L4_MABX_DW.Unit_Delay_35_DSTATE;

  L4_MABX_B.BrakingControlActive = L4_MABX_DW.Unit_Delay_36_DSTATE;

  L4_MABX_B.F_Hold_brakes_at_zero = L4_MABX_DW.Unit_Delay_37_DSTATE;

  L4_MABX_B.BrakingPID_Y = L4_MABX_DW.Unit_Delay_38_DSTATE;

  L4_MABX_B.BrakingPID_Y_Direct_Pressure = L4_MABX_DW.Unit_Delay_39_DSTATE;

  L4_MABX_B.DesSteeringPID_Pterm = L4_MABX_DW.Unit_Delay_4_DSTATE;

  L4_MABX_B.VSPD_TARGET_KPH_APV_h = L4_MABX_DW.Unit_Delay_40_DSTATE;

  L4_MABX_B.Vehicle_speed_target = L4_MABX_DW.Unit_Delay_41_DSTATE;

  L4_MABX_B.VSPD_HYST_KPH_APV = L4_MABX_DW.Unit_Delay_42_DSTATE;

  L4_MABX_B.VSPD_BRAKE_STOP_THRESH_KPH_APV = L4_MABX_DW.Unit_Delay_43_DSTATE;

  L4_MABX_B.ACCEL_LIM_MS2_APV = L4_MABX_DW.Unit_Delay_44_DSTATE;

  L4_MABX_B.AutonomousOutputEnabled_n = L4_MABX_DW.Unit_Delay_46_DSTATE;

  L4_MABX_B.DesSteeringPID_Y = L4_MABX_DW.Unit_Delay_5_DSTATE;

  L4_MABX_B.DesSteeringPID_e = L4_MABX_DW.Unit_Delay_6_DSTATE;

  L4_MABX_B.DeSteeringPID_Y2 = L4_MABX_DW.Unit_Delay_7_DSTATE;

  L4_MABX_B.CurvatureEst = L4_MABX_DW.Unit_Delay_8_DSTATE;

  L4_MABX_B.EngagePB_g = L4_MABX_DW.Unit_Delay_82_DSTATE;

  L4_MABX_B.PedalPWMPos = L4_MABX_DW.Unit_Delay_85_DSTATE;

  L4_MABX_B.IgnitionKeySwitch_voltage_c = L4_MABX_DW.Unit_Delay_86_DSTATE;

  L4_MABX_B.BrakeSwitch_a = L4_MABX_DW.Unit_Delay_87_DSTATE;

  L4_MABX_B.Park_brake_switch = L4_MABX_DW.Unit_Delay_88_DSTATE;

  L4_MABX_B.CruiseCtrlEnableSwitch = L4_MABX_DW.Unit_Delay_89_DSTATE;

  L4_MABX_B.Stanley_axleAngle = L4_MABX_DW.Unit_Delay_9_DSTATE;

  L4_MABX_B.FrontAxleSpeed = L4_MABX_DW.Unit_Delay_90_DSTATE;

  L4_MABX_B.FrontAxleLeftWheelSpeed = L4_MABX_DW.Unit_Delay_91_DSTATE;

  L4_MABX_B.FrontAxleRightWheelSpeed = L4_MABX_DW.Unit_Delay_92_DSTATE;

  L4_MABX_B.EBSBrakeSwitch = L4_MABX_DW.Unit_Delay_93_DSTATE;

  L4_MABX_B.SPN524_TransSelectedGear_m = L4_MABX_DW.Unit_Delay_94_DSTATE;

  L4_MABX_B.SPN523_TransCurrentGear_n = L4_MABX_DW.Unit_Delay_95_DSTATE;

  L4_MABX_B.SPN526_TransActualGearRatio_f = L4_MABX_DW.Unit_Delay_96_DSTATE;

  L4_MABX_B.ActualEngPercentTorque = L4_MABX_DW.Unit_Delay_97_DSTATE;

  L4_MABX_B.ActlEngPrcntTrqueHighResolution = L4_MABX_DW.Unit_Delay_98_DSTATE;

  L4_MABX_B.EngSpeed = L4_MABX_DW.Unit_Delay_99_DSTATE;



  /* DataTypeConversion: '<S532>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_ke = L4_MABX_B.DataTypeConversion_bq[0];



  /* DataTypeConversion: '<S532>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_li = L4_MABX_B.DataTypeConversion_bq[1];



  /* ArithShift: '<S532>/Shift Arithmetic' */

  L4_MABX_B.ShiftArithmetic_h = (uint16_T)(L4_MABX_B.DataTypeConversion1_li << 8);



  /* S-Function (sfix_bitop): '<S559>/Operator' */

  L4_MABX_B.Operator_b3 = (uint16_T)(L4_MABX_B.DataTypeConversion_ke |

    L4_MABX_B.ShiftArithmetic_h);



  /* DataTypeConversion: '<S559>/DataType' */

  L4_MABX_B.DataType_eq = L4_MABX_B.Operator_b3;



  /* DataTypeConversion: '<S532>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_b = L4_MABX_B.DataType_eq;



  /* Product: '<S532>/Product' incorporates:

   *  Constant: '<S532>/Constant'

   */

  L4_MABX_B.SPN188_EngineSpeedAtIdlePoint1 = L4_MABX_B.DataTypeConversion2_b *

    L4_MABX_P.Constant_Value_g3;



  /* DataTypeConversion: '<S424>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_a = L4_MABX_B.SPN188_EngineSpeedAtIdlePoint1;



  /* DataTypeConversion: '<S539>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_c = L4_MABX_B.DataTypeConversion_bq[2];



  /* Sum: '<S539>/Add' incorporates:

   *  Constant: '<S539>/Constant'

   */

  L4_MABX_B.SPN539_EnginePercentTorqueAtIdl = L4_MABX_B.DataTypeConversion_c +

    L4_MABX_P.Constant_Value_ou;



  /* DataTypeConversion: '<S424>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_f = L4_MABX_B.SPN539_EnginePercentTorqueAtIdl;



  /* DataTypeConversion: '<S536>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_o = L4_MABX_B.DataTypeConversion_bq[15];



  /* DataTypeConversion: '<S536>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_hdz = L4_MABX_B.DataTypeConversion_bq[16];



  /* ArithShift: '<S536>/Shift Arithmetic' */

  L4_MABX_B.ShiftArithmetic_k = (uint16_T)(L4_MABX_B.DataTypeConversion1_hdz <<

    8);



  /* S-Function (sfix_bitop): '<S561>/Operator' */

  L4_MABX_B.Operator_lb = (uint16_T)(L4_MABX_B.DataTypeConversion_o |

    L4_MABX_B.ShiftArithmetic_k);



  /* DataTypeConversion: '<S561>/DataType' */

  L4_MABX_B.DataType_ni = L4_MABX_B.Operator_lb;



  /* DataTypeConversion: '<S536>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_ft = L4_MABX_B.DataType_ni;



  /* Product: '<S536>/Product' incorporates:

   *  Constant: '<S536>/Constant'

   */

  L4_MABX_B.SPN532_EngineSpeedAtHighIdlePoi = L4_MABX_B.DataTypeConversion2_ft *

    L4_MABX_P.Constant_Value_pj;



  /* DataTypeConversion: '<S424>/Data Type Conversion10' */

  L4_MABX_B.DataTypeConversion10 = L4_MABX_B.SPN532_EngineSpeedAtHighIdlePoi;



  /* DataTypeConversion: '<S537>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_hs = L4_MABX_B.DataTypeConversion_bq[17];



  /* DataTypeConversion: '<S537>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_k = L4_MABX_B.DataTypeConversion_bq[18];



  /* ArithShift: '<S537>/Shift Arithmetic' */

  L4_MABX_B.ShiftArithmetic_m = (uint16_T)(L4_MABX_B.DataTypeConversion3_k << 8);



  /* S-Function (sfix_bitop): '<S562>/Operator' */

  L4_MABX_B.Operator_c = (uint16_T)(L4_MABX_B.DataTypeConversion1_hs |

    L4_MABX_B.ShiftArithmetic_m);



  /* DataTypeConversion: '<S562>/DataType' */

  L4_MABX_B.DataType_ce = L4_MABX_B.Operator_c;



  /* DataTypeConversion: '<S537>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_i = L4_MABX_B.DataType_ce;



  /* Product: '<S537>/Product' incorporates:

   *  Constant: '<S537>/Constant'

   */

  L4_MABX_B.SPN545_EngineGainKpOfTheEndspee = L4_MABX_B.DataTypeConversion2_i *

    L4_MABX_P.Constant_Value_lk;



  /* DataTypeConversion: '<S424>/Data Type Conversion11' */

  L4_MABX_B.DataTypeConversion11 = L4_MABX_B.SPN545_EngineGainKpOfTheEndspee;



  /* DataTypeConversion: '<S540>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_bu = L4_MABX_B.DataTypeConversion_bq[21];



  /* DataTypeConversion: '<S540>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_b = L4_MABX_B.DataTypeConversion_bq[22];



  /* ArithShift: '<S540>/Shift Arithmetic' */

  L4_MABX_B.ShiftArithmetic_i = (uint16_T)(L4_MABX_B.DataTypeConversion3_b << 8);



  /* S-Function (sfix_bitop): '<S564>/Operator' */

  L4_MABX_B.Operator_ha = (uint16_T)(L4_MABX_B.DataTypeConversion1_bu |

    L4_MABX_B.ShiftArithmetic_i);



  /* DataTypeConversion: '<S564>/DataType' */

  L4_MABX_B.DataType_bi = L4_MABX_B.Operator_ha;



  /* DataTypeConversion: '<S540>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_a = L4_MABX_B.DataType_bi;



  /* Product: '<S540>/Product' incorporates:

   *  Constant: '<S540>/Constant'

   */

  L4_MABX_B.SPN533_EngineMaximumMomentaryOv = L4_MABX_B.DataTypeConversion2_a *

    L4_MABX_P.Constant_Value_on;



  /* DataTypeConversion: '<S424>/Data Type Conversion13' */

  L4_MABX_B.DataTypeConversion13 = L4_MABX_B.SPN533_EngineMaximumMomentaryOv;



  /* DataTypeConversion: '<S541>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_e = L4_MABX_B.DataTypeConversion_bq[23];



  /* Product: '<S541>/Product' incorporates:

   *  Constant: '<S541>/Constant'

   */

  L4_MABX_B.SPN534_EngineMaximumMomentaryOv = L4_MABX_B.DataTypeConversion2_e *

    L4_MABX_P.Constant_Value_gt;



  /* DataTypeConversion: '<S424>/Data Type Conversion14' */

  L4_MABX_B.DataTypeConversion14 = L4_MABX_B.SPN534_EngineMaximumMomentaryOv;



  /* DataTypeConversion: '<S542>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_g = L4_MABX_B.DataTypeConversion_bq[24];



  /* Product: '<S542>/Product' incorporates:

   *  Constant: '<S542>/Constant'

   */

  L4_MABX_B.SPN535_EngineRequestedSpeedCont = L4_MABX_B.DataTypeConversion2_g *

    L4_MABX_P.Constant_Value_n2;



  /* DataTypeConversion: '<S424>/Data Type Conversion15' */

  L4_MABX_B.DataTypeConversion15 = L4_MABX_B.SPN535_EngineRequestedSpeedCont;



  /* DataTypeConversion: '<S543>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_fj = L4_MABX_B.DataTypeConversion_bq[25];



  /* Product: '<S543>/Product' incorporates:

   *  Constant: '<S543>/Constant'

   */

  L4_MABX_B.SPN536_EngineRequestedSpeedCont = L4_MABX_B.DataTypeConversion2_fj *

    L4_MABX_P.Constant_Value_ah;



  /* DataTypeConversion: '<S424>/Data Type Conversion16' */

  L4_MABX_B.DataTypeConversion16 = L4_MABX_B.SPN536_EngineRequestedSpeedCont;



  /* DataTypeConversion: '<S544>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_n = L4_MABX_B.DataTypeConversion_bq[26];



  /* Sum: '<S544>/Add' incorporates:

   *  Constant: '<S544>/Constant'

   */

  L4_MABX_B.SPN537_EngineRequestedTorqueCon = L4_MABX_B.DataTypeConversion_n +

    L4_MABX_P.Constant_Value_jd;



  /* DataTypeConversion: '<S424>/Data Type Conversion17' */

  L4_MABX_B.DataTypeConversion17 = L4_MABX_B.SPN537_EngineRequestedTorqueCon;



  /* DataTypeConversion: '<S545>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_i = L4_MABX_B.DataTypeConversion_bq[27];



  /* Sum: '<S545>/Add' incorporates:

   *  Constant: '<S545>/Constant'

   */

  L4_MABX_B.SPN538_EngineRequestedTorqueCon = L4_MABX_B.DataTypeConversion_i +

    L4_MABX_P.Constant_Value_is;



  /* DataTypeConversion: '<S424>/Data Type Conversion18' */

  L4_MABX_B.DataTypeConversion18 = L4_MABX_B.SPN538_EngineRequestedTorqueCon;



  /* DataTypeConversion: '<S546>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_iu = L4_MABX_B.DataTypeConversion_bq[28];



  /* DataTypeConversion: '<S546>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_jk = L4_MABX_B.DataTypeConversion_bq[29];



  /* ArithShift: '<S546>/Shift Arithmetic' */

  L4_MABX_B.ShiftArithmetic_g = (uint16_T)(L4_MABX_B.DataTypeConversion3_jk << 8);



  /* S-Function (sfix_bitop): '<S565>/Operator' */

  L4_MABX_B.Operator_bt = (uint16_T)(L4_MABX_B.DataTypeConversion1_iu |

    L4_MABX_B.ShiftArithmetic_g);



  /* DataTypeConversion: '<S565>/DataType' */

  L4_MABX_B.DataType_dv = L4_MABX_B.Operator_bt;



  /* DataTypeConversion: '<S546>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_ae = L4_MABX_B.DataType_dv;



  /* Product: '<S546>/Product' incorporates:

   *  Constant: '<S546>/Constant'

   */

  L4_MABX_B.SPN1712_EngRequestedSpeedCtrlRn = L4_MABX_B.DataTypeConversion2_ae *

    L4_MABX_P.Constant_Value_o5;



  /* DataTypeConversion: '<S424>/Data Type Conversion19' */

  L4_MABX_B.DataTypeConversion19 = L4_MABX_B.SPN1712_EngRequestedSpeedCtrlRn;



  /* DataTypeConversion: '<S554>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_ef = L4_MABX_B.DataTypeConversion_bq[3];



  /* DataTypeConversion: '<S554>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_lg = L4_MABX_B.DataTypeConversion_bq[4];



  /* ArithShift: '<S554>/Shift Arithmetic' */

  L4_MABX_B.ShiftArithmetic_hv = (uint16_T)(L4_MABX_B.DataTypeConversion1_lg <<

    8);



  /* S-Function (sfix_bitop): '<S568>/Operator' */

  L4_MABX_B.Operator_nd = (uint16_T)(L4_MABX_B.DataTypeConversion_ef |

    L4_MABX_B.ShiftArithmetic_hv);



  /* DataTypeConversion: '<S568>/DataType' */

  L4_MABX_B.DataType_ak = L4_MABX_B.Operator_nd;



  /* DataTypeConversion: '<S554>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_n = L4_MABX_B.DataType_ak;



  /* Product: '<S554>/Product' incorporates:

   *  Constant: '<S554>/Constant'

   */

  L4_MABX_B.SPN528_EngineSpeedAtPoint2 = L4_MABX_B.DataTypeConversion2_n *

    L4_MABX_P.Constant_Value_gx;



  /* DataTypeConversion: '<S424>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_c = L4_MABX_B.SPN528_EngineSpeedAtPoint2;



  /* DataTypeConversion: '<S547>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_gi = L4_MABX_B.DataTypeConversion_bq[30];



  /* DataTypeConversion: '<S547>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_d = L4_MABX_B.DataTypeConversion_bq[31];



  /* ArithShift: '<S547>/Shift Arithmetic' */

  L4_MABX_B.ShiftArithmetic_iu = (uint16_T)(L4_MABX_B.DataTypeConversion3_d << 8);



  /* S-Function (sfix_bitop): '<S566>/Operator' */

  L4_MABX_B.Operator_gs = (uint16_T)(L4_MABX_B.DataTypeConversion1_gi |

    L4_MABX_B.ShiftArithmetic_iu);



  /* DataTypeConversion: '<S566>/DataType' */

  L4_MABX_B.DataType_ec = L4_MABX_B.Operator_gs;



  /* DataTypeConversion: '<S547>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_h = L4_MABX_B.DataType_ec;



  /* Product: '<S547>/Product' incorporates:

   *  Constant: '<S547>/Constant'

   */

  L4_MABX_B.SPN1794_EngineMomentOfInertia = L4_MABX_B.DataTypeConversion2_h *

    L4_MABX_P.Constant_Value_l1;



  /* DataTypeConversion: '<S424>/Data Type Conversion20' */

  L4_MABX_B.DataTypeConversion20 = L4_MABX_B.SPN1794_EngineMomentOfInertia;



  /* DataTypeConversion: '<S548>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_pf = L4_MABX_B.DataTypeConversion_bq[32];



  /* DataTypeConversion: '<S548>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_kq = L4_MABX_B.DataTypeConversion_bq[33];



  /* ArithShift: '<S548>/Shift Arithmetic' */

  L4_MABX_B.ShiftArithmetic_n = (uint16_T)(L4_MABX_B.DataTypeConversion1_kq << 8);



  /* S-Function (sfix_bitop): '<S567>/Operator' */

  L4_MABX_B.Operator_m = (uint16_T)(L4_MABX_B.DataTypeConversion_pf |

    L4_MABX_B.ShiftArithmetic_n);



  /* DataTypeConversion: '<S567>/DataType' */

  L4_MABX_B.DataType_be = L4_MABX_B.Operator_m;



  /* DataTypeConversion: '<S548>/Data Type Conversion2' */

  L4_MABX_B.SPN1846_EngineDefaultTorqueLimi = L4_MABX_B.DataType_be;



  /* DataTypeConversion: '<S424>/Data Type Conversion21' */

  L4_MABX_B.DataTypeConversion21 = L4_MABX_B.SPN1846_EngineDefaultTorqueLimi;



  /* DataTypeConversion: '<S424>/Data Type Conversion22' */

  L4_MABX_B.DataTypeConversion22 = L4_MABX_B.DataTypeConversion_bq[34];



  /* DataTypeConversion: '<S424>/Data Type Conversion23' */

  L4_MABX_B.DataTypeConversion23 = L4_MABX_B.DataTypeConversion_bq[35];



  /* DataTypeConversion: '<S424>/Data Type Conversion24' */

  L4_MABX_B.DataTypeConversion24 = L4_MABX_B.DataTypeConversion_bq[36];



  /* DataTypeConversion: '<S424>/Data Type Conversion25' */

  L4_MABX_B.DataTypeConversion25 = L4_MABX_B.DataTypeConversion_bq[37];



  /* DataTypeConversion: '<S424>/Data Type Conversion26' */

  L4_MABX_B.DataTypeConversion26 = L4_MABX_B.DataTypeConversion_bq[38];



  /* DataTypeConversion: '<S555>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_b = L4_MABX_B.DataTypeConversion_bq[5];



  /* Sum: '<S555>/Add' incorporates:

   *  Constant: '<S555>/Constant'

   */

  L4_MABX_B.SPN540_EnginePercentTorqueAtPoi = L4_MABX_B.DataTypeConversion_b +

    L4_MABX_P.Constant_Value_o4u;



  /* DataTypeConversion: '<S424>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3 = L4_MABX_B.SPN540_EnginePercentTorqueAtPoi;



  /* DataTypeConversion: '<S556>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_eg = L4_MABX_B.DataTypeConversion_bq[6];



  /* DataTypeConversion: '<S556>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_hy = L4_MABX_B.DataTypeConversion_bq[7];



  /* ArithShift: '<S556>/Shift Arithmetic' */

  L4_MABX_B.ShiftArithmetic_hk = (uint16_T)(L4_MABX_B.DataTypeConversion1_hy <<

    8);



  /* S-Function (sfix_bitop): '<S569>/Operator' */

  L4_MABX_B.Operator_n1 = (uint16_T)(L4_MABX_B.DataTypeConversion_eg |

    L4_MABX_B.ShiftArithmetic_hk);



  /* DataTypeConversion: '<S569>/DataType' */

  L4_MABX_B.DataType_bd = L4_MABX_B.Operator_n1;



  /* DataTypeConversion: '<S556>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_er = L4_MABX_B.DataType_bd;



  /* Product: '<S556>/Product' incorporates:

   *  Constant: '<S556>/Constant'

   */

  L4_MABX_B.SPN529_EngineSpeedAtPoint3 = L4_MABX_B.DataTypeConversion2_er *

    L4_MABX_P.Constant_Value_pr;



  /* DataTypeConversion: '<S424>/Data Type Conversion4' */

  L4_MABX_B.DataTypeConversion4 = L4_MABX_B.SPN529_EngineSpeedAtPoint3;



  /* DataTypeConversion: '<S557>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_ce = L4_MABX_B.DataTypeConversion_bq[8];



  /* Sum: '<S557>/Add' incorporates:

   *  Constant: '<S557>/Constant'

   */

  L4_MABX_B.SPN541_EnginePercentTorqueAtPoi = L4_MABX_B.DataTypeConversion_ce +

    L4_MABX_P.Constant_Value_gy;



  /* DataTypeConversion: '<S424>/Data Type Conversion5' */

  L4_MABX_B.DataTypeConversion5 = L4_MABX_B.SPN541_EnginePercentTorqueAtPoi;



  /* DataTypeConversion: '<S558>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_kb = L4_MABX_B.DataTypeConversion_bq[9];



  /* DataTypeConversion: '<S558>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_lr = L4_MABX_B.DataTypeConversion_bq[10];



  /* ArithShift: '<S558>/Shift Arithmetic' */

  L4_MABX_B.ShiftArithmetic_j = (uint16_T)(L4_MABX_B.DataTypeConversion1_lr << 8);



  /* S-Function (sfix_bitop): '<S570>/Operator' */

  L4_MABX_B.Operator_ky = (uint16_T)(L4_MABX_B.DataTypeConversion_kb |

    L4_MABX_B.ShiftArithmetic_j);



  /* DataTypeConversion: '<S570>/DataType' */

  L4_MABX_B.DataType_ax = L4_MABX_B.Operator_ky;



  /* DataTypeConversion: '<S558>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_h3 = L4_MABX_B.DataType_ax;



  /* Product: '<S558>/Product' incorporates:

   *  Constant: '<S558>/Constant'

   */

  L4_MABX_B.SPN530_EngineSpeedAtPoint4 = L4_MABX_B.DataTypeConversion2_h3 *

    L4_MABX_P.Constant_Value_nn;



  /* DataTypeConversion: '<S424>/Data Type Conversion6' */

  L4_MABX_B.DataTypeConversion6 = L4_MABX_B.SPN530_EngineSpeedAtPoint4;



  /* DataTypeConversion: '<S533>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_j = L4_MABX_B.DataTypeConversion_bq[11];



  /* Sum: '<S533>/Add' incorporates:

   *  Constant: '<S533>/Constant'

   */

  L4_MABX_B.SPN542_EnginePercentTorqueAtPoi = L4_MABX_B.DataTypeConversion_j +

    L4_MABX_P.Constant_Value_m;



  /* DataTypeConversion: '<S424>/Data Type Conversion7' */

  L4_MABX_B.DataTypeConversion7 = L4_MABX_B.SPN542_EnginePercentTorqueAtPoi;



  /* DataTypeConversion: '<S534>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_ov = L4_MABX_B.DataTypeConversion_bq[12];



  /* DataTypeConversion: '<S534>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_fe = L4_MABX_B.DataTypeConversion_bq[13];



  /* ArithShift: '<S534>/Shift Arithmetic' */

  L4_MABX_B.ShiftArithmetic_j1 = (uint16_T)(L4_MABX_B.DataTypeConversion1_fe <<

    8);



  /* S-Function (sfix_bitop): '<S560>/Operator' */

  L4_MABX_B.Operator_hk = (uint16_T)(L4_MABX_B.DataTypeConversion_ov |

    L4_MABX_B.ShiftArithmetic_j1);



  /* DataTypeConversion: '<S560>/DataType' */

  L4_MABX_B.DataType_fv = L4_MABX_B.Operator_hk;



  /* DataTypeConversion: '<S534>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_p = L4_MABX_B.DataType_fv;



  /* Product: '<S534>/Product' incorporates:

   *  Constant: '<S534>/Constant'

   */

  L4_MABX_B.SPN531_EngineSpeedAtPoint5 = L4_MABX_B.DataTypeConversion2_p *

    L4_MABX_P.Constant_Value_ob;



  /* DataTypeConversion: '<S424>/Data Type Conversion8' */

  L4_MABX_B.DataTypeConversion8 = L4_MABX_B.SPN531_EngineSpeedAtPoint5;



  /* DataTypeConversion: '<S535>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_dt = L4_MABX_B.DataTypeConversion_bq[14];



  /* Sum: '<S535>/Add' incorporates:

   *  Constant: '<S535>/Constant'

   */

  L4_MABX_B.SPN543_EnginePercentTorqueAtPoi = L4_MABX_B.DataTypeConversion_dt +

    L4_MABX_P.Constant_Value_pn;



  /* DataTypeConversion: '<S424>/Data Type Conversion9' */

  L4_MABX_B.DataTypeConversion9 = L4_MABX_B.SPN543_EnginePercentTorqueAtPoi;



  /* DataTypeConversion: '<S481>/Data Type Conversion8' */

  L4_MABX_B.RX_status_p = (L4_MABX_B.SFunction1_o9_ad != 0.0);



  /* MultiPortSwitch: '<S427>/Multiport_Switch' */

  L4_MABX_B.RX_status_gp = L4_MABX_B.RX_status_p;



  /* DataTypeConversion: '<S481>/Data Type Conversion9' */

  L4_MABX_B.RX_time = L4_MABX_B.SFunction1_o10_n;



  /* MultiPortSwitch: '<S427>/Multiport_Switch' */

  L4_MABX_B.RX_time_p = L4_MABX_B.RX_time;



  /* DataTypeConversion: '<S481>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time = L4_MABX_B.SFunction1_o11_p;



  /* MultiPortSwitch: '<S427>/Multiport_Switch' */

  L4_MABX_B.RX_delta_time_c = L4_MABX_B.RX_delta_time;



  /* RelationalOperator: '<S485>/Operator' incorporates:

   *  Constant: '<S427>/Constant'

   *  Constant: '<S482>/Constant1'

   */

  L4_MABX_B.Operator_pa = (L4_MABX_P.Constant_Value_by3 ==

    L4_MABX_P.Constant1_Value_bd);



  /* RelationalOperator: '<S486>/Operator' incorporates:

   *  Constant: '<S427>/Constant'

   *  Constant: '<S482>/Constant2'

   */

  L4_MABX_B.Operator_hf = (L4_MABX_P.Constant_Value_by3 ==

    L4_MABX_P.Constant2_Value_ar);



  /* RelationalOperator: '<S487>/Operator' incorporates:

   *  Constant: '<S427>/Constant'

   *  Constant: '<S482>/Constant3'

   */

  L4_MABX_B.Operator_cuv = (L4_MABX_P.Constant_Value_by3 ==

    L4_MABX_P.Constant3_Value_d1);



  /* RelationalOperator: '<S488>/Operator' incorporates:

   *  Constant: '<S427>/Constant'

   *  Constant: '<S482>/Constant4'

   */

  L4_MABX_B.Operator_ca = (L4_MABX_P.Constant_Value_by3 ==

    L4_MABX_P.Constant4_Value_i);



  /* RelationalOperator: '<S489>/Operator' incorporates:

   *  Constant: '<S427>/Constant'

   *  Constant: '<S482>/Constant5'

   */

  L4_MABX_B.Operator_k2 = (L4_MABX_P.Constant_Value_by3 ==

    L4_MABX_P.Constant5_Value_c);



  /* DataTypeConversion: '<S490>/Data Type Conversion9' */

  L4_MABX_B.RX_time_g = L4_MABX_B.SFunction1_o10_hj;



  /* MultiPortSwitch: '<S428>/Multiport_Switch' */

  L4_MABX_B.RX_time_l = L4_MABX_B.RX_time_g;



  /* DataTypeConversion: '<S490>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_o = L4_MABX_B.SFunction1_o11_h;



  /* MultiPortSwitch: '<S428>/Multiport_Switch' */

  L4_MABX_B.RX_delta_time_j = L4_MABX_B.RX_delta_time_o;



  /* RelationalOperator: '<S494>/Operator' incorporates:

   *  Constant: '<S428>/Constant'

   *  Constant: '<S491>/Constant1'

   */

  L4_MABX_B.Operator_dbr = (L4_MABX_P.Constant_Value_ek ==

    L4_MABX_P.Constant1_Value_d);



  /* RelationalOperator: '<S495>/Operator' incorporates:

   *  Constant: '<S428>/Constant'

   *  Constant: '<S491>/Constant2'

   */

  L4_MABX_B.Operator_hfh = (L4_MABX_P.Constant_Value_ek ==

    L4_MABX_P.Constant2_Value_pr);



  /* RelationalOperator: '<S496>/Operator' incorporates:

   *  Constant: '<S428>/Constant'

   *  Constant: '<S491>/Constant3'

   */

  L4_MABX_B.Operator_my = (L4_MABX_P.Constant_Value_ek ==

    L4_MABX_P.Constant3_Value_o);



  /* RelationalOperator: '<S497>/Operator' incorporates:

   *  Constant: '<S428>/Constant'

   *  Constant: '<S491>/Constant4'

   */

  L4_MABX_B.Operator_ayb = (L4_MABX_P.Constant_Value_ek ==

    L4_MABX_P.Constant4_Value_f);



  /* RelationalOperator: '<S498>/Operator' incorporates:

   *  Constant: '<S428>/Constant'

   *  Constant: '<S491>/Constant5'

   */

  L4_MABX_B.Operator_aw = (L4_MABX_P.Constant_Value_ek ==

    L4_MABX_P.Constant5_Value_pd);



  /* DataTypeConversion: '<S499>/Data Type Conversion1' */

  L4_MABX_B.SpeedOfForwardVehicle = L4_MABX_B.SFunction1_o1_de;



  /* DataTypeConversion: '<S499>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_a = L4_MABX_B.SFunction1_o13_or;



  /* DataTypeConversion: '<S499>/Data Type Conversion11' */

  L4_MABX_B.ACCSystemShutoffWarning = L4_MABX_B.SFunction1_o8_oi;



  /* DataTypeConversion: '<S499>/Data Type Conversion2' */

  L4_MABX_B.DistanceToForwardVehicle = L4_MABX_B.SFunction1_o2_d5;



  /* DataTypeConversion: '<S499>/Data Type Conversion3' */

  L4_MABX_B.AdaptiveCruiseCtrlSetSpeed = L4_MABX_B.SFunction1_o3_dg;



  /* DataTypeConversion: '<S499>/Data Type Conversion4' */

  L4_MABX_B.AdaptiveCruiseCtrlMode = L4_MABX_B.SFunction1_o4_bc;



  /* DataTypeConversion: '<S499>/Data Type Conversion5' */

  L4_MABX_B.AdptveCruiseCtrlSetDistanceMode = L4_MABX_B.SFunction1_o5_k4;



  /* DataTypeConversion: '<S499>/Data Type Conversion6' */

  L4_MABX_B.RoadCurvature = L4_MABX_B.SFunction1_o6_j5;



  /* DataTypeConversion: '<S499>/Data Type Conversion7' */

  L4_MABX_B.ACCTargetDetected = L4_MABX_B.SFunction1_o7_hh;



  /* DataTypeConversion: '<S499>/Data Type Conversion8' */

  L4_MABX_B.RX_status_k = (L4_MABX_B.SFunction1_o11_mg != 0.0);



  /* DataTypeConversion: '<S499>/Data Type Conversion9' */

  L4_MABX_B.RX_time_m = L4_MABX_B.SFunction1_o12_n;



  /* Outputs for Enabled SubSystem: '<S501>/AEBS1_A0' incorporates:

   *  EnablePort: '<S502>/Enable'

   */

  /* Constant: '<S430>/Constant' */

  if (L4_MABX_P.Constant_Value_nd) {

    /* S-Function (rti_commonblock): '<S502>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "AEBS1_A0" Id:217067306 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCF02F2A].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCF02F2A].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o6_pv = 1.0;

        L4_MABX_B.SFunction1_o7_jm = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCF02F2A].timestamp;

        L4_MABX_B.SFunction1_o8_cl = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCF02F2A].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0xCF02F2A].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "AdvEmergencyBrkSysState" (0|4, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x0000000F;

            L4_MABX_B.SFunction1_o1_jc = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "CollisionWarningLevel" (4|4, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x0000000F;

            L4_MABX_B.SFunction1_o2_pw = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "RelObjctDetForAdvEmergBrakingSys" (8|3, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x00000007;

            L4_MABX_B.SFunction1_o3_km = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "BendOffProbabOfRelevantObject" (12|3, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000007;

            L4_MABX_B.SFunction1_o4_ke = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "TimeToCollisionWithRelevantObj" (16|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o5_pv = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o6_pv = 0.0;

      }

    }

  }



  /* End of Constant: '<S430>/Constant' */

  /* End of Outputs for SubSystem: '<S501>/AEBS1_A0' */



  /* DataTypeConversion: '<S501>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_d = L4_MABX_B.SFunction1_o8_cl;



  /* DataTypeConversion: '<S501>/Data Type Conversion8' */

  L4_MABX_B.RX_status_l = (L4_MABX_B.SFunction1_o6_pv != 0.0);



  /* DataTypeConversion: '<S501>/Data Type Conversion9' */

  L4_MABX_B.RX_time_n = L4_MABX_B.SFunction1_o7_jm;



  /* DataTypeConversion: '<S503>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_de = L4_MABX_B.SFunction1_o11_a3;



  /* DataTypeConversion: '<S503>/Data Type Conversion8' */

  L4_MABX_B.RX_status_gx = (L4_MABX_B.SFunction1_o9_kh != 0.0);



  /* DataTypeConversion: '<S503>/Data Type Conversion9' */

  L4_MABX_B.RX_time_nm = L4_MABX_B.SFunction1_o10_dt;



  /* DataTypeConversion: '<S505>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_k = L4_MABX_B.SFunction1_o8_i;



  /* DataTypeConversion: '<S505>/Data Type Conversion8' */

  L4_MABX_B.RX_status_c = (L4_MABX_B.SFunction1_o6_j0 != 0.0);



  /* DataTypeConversion: '<S505>/Data Type Conversion9' */

  L4_MABX_B.RX_time_i = L4_MABX_B.SFunction1_o7_m;



  /* Outputs for Enabled SubSystem: '<S507>/B2' incorporates:

   *  EnablePort: '<S508>/Enable'

   */

  /* Constant: '<S433>/Constant' */

  if (L4_MABX_P.Constant_Value_it > 0.0) {

    /* S-Function (rti_commonblock): '<S508>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "B2" Id:418451505 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F11031].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F11031].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o3_o1 = 1.0;

        L4_MABX_B.SFunction1_o4_md = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F11031].timestamp;

        L4_MABX_B.SFunction1_o5_lj = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F11031].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F11031].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "BrakeAppPressDemanded" (0|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o1_pc = 0.1 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "BrakeSwitch2" (16|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o2_bz = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o3_o1 = 0.0;

      }

    }

  }



  /* End of Constant: '<S433>/Constant' */

  /* End of Outputs for SubSystem: '<S507>/B2' */



  /* DataTypeConversion: '<S507>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_jt = L4_MABX_B.SFunction1_o5_lj;



  /* DataTypeConversion: '<S507>/Data Type Conversion8' */

  L4_MABX_B.RX_status_h4 = (L4_MABX_B.SFunction1_o3_o1 != 0.0);



  /* DataTypeConversion: '<S507>/Data Type Conversion9' */

  L4_MABX_B.RX_time_pq = L4_MABX_B.SFunction1_o4_md;



  /* Outputs for Enabled SubSystem: '<S509>/Tracks' incorporates:

   *  EnablePort: '<S510>/Enable'

   */

  /* Constant: '<S434>/Constant' */

  if (L4_MABX_P.Constant_Value_a0) {

    /* S-Function (rti_commonblock): '<S510>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "Tracks" Id:1635 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M2_C1_STD[CANTP1_M2_C1_RXSRVC_STD_0x663].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M2_C1_STD[CANTP1_M2_C1_RXSRVC_STD_0x663].timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o72 = 1.0;

        L4_MABX_B.SFunction1_o73 = (real_T)

          can_type1_M2_C1_STD[CANTP1_M2_C1_RXSRVC_STD_0x663].timestamp;

        L4_MABX_B.SFunction1_o74 = (real_T)

          can_type1_M2_C1_STD[CANTP1_M2_C1_RXSRVC_STD_0x663].deltatime;

        CAN_Msg = can_type1_M2_C1_STD[CANTP1_M2_C1_RXSRVC_STD_0x663].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;

            UInt32 modeSignal;



            /* ...... "track_multiplexor" (56|8, mode signal, unsigned int, motorola back.) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o71 = ((real_T) CAN_Sgn.UnsignedSgn);

            modeSignal = (UInt32) L4_MABX_B.SFunction1_o71;

            if (modeSignal == 4) {

              /* ...... "tr0_track_selection_status" (0|13, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.UnsignedSgn &= 0x00001FFF;

              L4_MABX_B.SFunction1_o1_ly = ((real_T) CAN_Sgn.UnsignedSgn);

            }



            if (modeSignal == 5) {

              /* ...... "tr0_corrected_lateral_distance" (0|16, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.SignedSgn &= 0x0000FFFF;

              if (CAN_Sgn.SignedSgn >> 15) {

                CAN_Sgn.SignedSgn |= 0xFFFF0000;

              }



              L4_MABX_B.SFunction1_o2_fl = 0.001 * ( ((real_T) CAN_Sgn.SignedSgn)

                );

            }



            if (modeSignal == 12) {

              /* ...... "tr1_track_selection_status" (0|13, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.UnsignedSgn &= 0x00001FFF;

              L4_MABX_B.SFunction1_o3_os = ((real_T) CAN_Sgn.UnsignedSgn);

            }



            if (modeSignal == 13) {

              /* ...... "tr1_corrected_lateral_distance" (0|16, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.SignedSgn &= 0x0000FFFF;

              if (CAN_Sgn.SignedSgn >> 15) {

                CAN_Sgn.SignedSgn |= 0xFFFF0000;

              }



              L4_MABX_B.SFunction1_o4_dz = 0.001 * ( ((real_T) CAN_Sgn.SignedSgn)

                );

            }



            if (modeSignal == 20) {

              /* ...... "tr2_track_selection_status" (0|13, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.UnsignedSgn &= 0x00001FFF;

              L4_MABX_B.SFunction1_o5_pr = ((real_T) CAN_Sgn.UnsignedSgn);

            }



            if (modeSignal == 21) {

              /* ...... "tr2_corrected_lateral_distance" (0|16, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.SignedSgn &= 0x0000FFFF;

              if (CAN_Sgn.SignedSgn >> 15) {

                CAN_Sgn.SignedSgn |= 0xFFFF0000;

              }



              L4_MABX_B.SFunction1_o6_hf = 0.001 * ( ((real_T) CAN_Sgn.SignedSgn)

                );

            }



            if (modeSignal == 28) {

              /* ...... "tr3_track_selection_status" (0|13, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.UnsignedSgn &= 0x00001FFF;

              L4_MABX_B.SFunction1_o7_pz = ((real_T) CAN_Sgn.UnsignedSgn);

            }



            if (modeSignal == 29) {

              /* ...... "tr3_corrected_lateral_distance" (0|16, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.SignedSgn &= 0x0000FFFF;

              if (CAN_Sgn.SignedSgn >> 15) {

                CAN_Sgn.SignedSgn |= 0xFFFF0000;

              }



              L4_MABX_B.SFunction1_o8_g = 0.001 * ( ((real_T) CAN_Sgn.SignedSgn)

                );

            }



            if (modeSignal == 36) {

              /* ...... "tr4_track_selection_status" (0|13, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.UnsignedSgn &= 0x00001FFF;

              L4_MABX_B.SFunction1_o9_g5 = ((real_T) CAN_Sgn.UnsignedSgn);

            }



            if (modeSignal == 37) {

              /* ...... "tr4_corrected_lateral_distance" (0|16, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.SignedSgn &= 0x0000FFFF;

              if (CAN_Sgn.SignedSgn >> 15) {

                CAN_Sgn.SignedSgn |= 0xFFFF0000;

              }



              L4_MABX_B.SFunction1_o10_d5 = 0.001 * ( ((real_T)

                CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 44) {

              /* ...... "tr5_track_selection_status" (0|13, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.UnsignedSgn &= 0x00001FFF;

              L4_MABX_B.SFunction1_o11_by = ((real_T) CAN_Sgn.UnsignedSgn);

            }



            if (modeSignal == 45) {

              /* ...... "tr5_corrected_lateral_distance" (0|16, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.SignedSgn &= 0x0000FFFF;

              if (CAN_Sgn.SignedSgn >> 15) {

                CAN_Sgn.SignedSgn |= 0xFFFF0000;

              }



              L4_MABX_B.SFunction1_o12_b = 0.001 * ( ((real_T) CAN_Sgn.SignedSgn)

                );

            }



            if (modeSignal == 52) {

              /* ...... "tr6_track_selection_status" (0|13, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.UnsignedSgn &= 0x00001FFF;

              L4_MABX_B.SFunction1_o13_g0 = ((real_T) CAN_Sgn.UnsignedSgn);

            }



            if (modeSignal == 53) {

              /* ...... "tr6_corrected_lateral_distance" (0|16, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.SignedSgn &= 0x0000FFFF;

              if (CAN_Sgn.SignedSgn >> 15) {

                CAN_Sgn.SignedSgn |= 0xFFFF0000;

              }



              L4_MABX_B.SFunction1_o14_nc = 0.001 * ( ((real_T)

                CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 60) {

              /* ...... "tr7_track_selection_status" (0|13, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.UnsignedSgn &= 0x00001FFF;

              L4_MABX_B.SFunction1_o15_ag = ((real_T) CAN_Sgn.UnsignedSgn);

            }



            if (modeSignal == 61) {

              /* ...... "tr7_corrected_lateral_distance" (0|16, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.SignedSgn &= 0x0000FFFF;

              if (CAN_Sgn.SignedSgn >> 15) {

                CAN_Sgn.SignedSgn |= 0xFFFF0000;

              }



              L4_MABX_B.SFunction1_o16_c = 0.001 * ( ((real_T) CAN_Sgn.SignedSgn)

                );

            }



            if (modeSignal == 68) {

              /* ...... "tr8_track_selection_status" (0|13, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.UnsignedSgn &= 0x00001FFF;

              L4_MABX_B.SFunction1_o17_b = ((real_T) CAN_Sgn.UnsignedSgn);

            }



            if (modeSignal == 69) {

              /* ...... "tr8_corrected_lateral_distance" (0|16, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.SignedSgn &= 0x0000FFFF;

              if (CAN_Sgn.SignedSgn >> 15) {

                CAN_Sgn.SignedSgn |= 0xFFFF0000;

              }



              L4_MABX_B.SFunction1_o18_b = 0.001 * ( ((real_T) CAN_Sgn.SignedSgn)

                );

            }



            if (modeSignal == 76) {

              /* ...... "tr9_track_selection_status" (0|13, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.UnsignedSgn &= 0x00001FFF;

              L4_MABX_B.SFunction1_o19_n = ((real_T) CAN_Sgn.UnsignedSgn);

            }



            if (modeSignal == 77) {

              /* ...... "tr9_corrected_lateral_distance" (0|16, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[6];

              CAN_Sgn.SignedSgn &= 0x0000FFFF;

              if (CAN_Sgn.SignedSgn >> 15) {

                CAN_Sgn.SignedSgn |= 0xFFFF0000;

              }



              L4_MABX_B.SFunction1_o20_j = 0.001 * ( ((real_T) CAN_Sgn.SignedSgn)

                );

            }



            if (modeSignal == 6) {

              /* ...... "tr0_lateral_position" (14|10, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

              CAN_Sgn.SignedSgn = ((UInt32)CAN_Sgn.SignedSgn) >> 6;

              CAN_Sgn.SignedSgn &= 0x000003FF;

              if (CAN_Sgn.SignedSgn >> 9) {

                CAN_Sgn.SignedSgn |= 0xFFFFFC00;

              }



              L4_MABX_B.SFunction1_o21_e5 = 0.1 * ( ((real_T) CAN_Sgn.SignedSgn)

                );

            }



            if (modeSignal == 14) {

              /* ...... "tr1_lateral_position" (14|10, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

              CAN_Sgn.SignedSgn = ((UInt32)CAN_Sgn.SignedSgn) >> 6;

              CAN_Sgn.SignedSgn &= 0x000003FF;

              if (CAN_Sgn.SignedSgn >> 9) {

                CAN_Sgn.SignedSgn |= 0xFFFFFC00;

              }



              L4_MABX_B.SFunction1_o22_f = 0.1 * ( ((real_T) CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 22) {

              /* ...... "tr2_lateral_position" (14|10, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

              CAN_Sgn.SignedSgn = ((UInt32)CAN_Sgn.SignedSgn) >> 6;

              CAN_Sgn.SignedSgn &= 0x000003FF;

              if (CAN_Sgn.SignedSgn >> 9) {

                CAN_Sgn.SignedSgn |= 0xFFFFFC00;

              }



              L4_MABX_B.SFunction1_o23_e = 0.1 * ( ((real_T) CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 30) {

              /* ...... "tr3_lateral_position" (14|10, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

              CAN_Sgn.SignedSgn = ((UInt32)CAN_Sgn.SignedSgn) >> 6;

              CAN_Sgn.SignedSgn &= 0x000003FF;

              if (CAN_Sgn.SignedSgn >> 9) {

                CAN_Sgn.SignedSgn |= 0xFFFFFC00;

              }



              L4_MABX_B.SFunction1_o24_g = 0.1 * ( ((real_T) CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 38) {

              /* ...... "tr4_lateral_position" (14|10, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

              CAN_Sgn.SignedSgn = ((UInt32)CAN_Sgn.SignedSgn) >> 6;

              CAN_Sgn.SignedSgn &= 0x000003FF;

              if (CAN_Sgn.SignedSgn >> 9) {

                CAN_Sgn.SignedSgn |= 0xFFFFFC00;

              }



              L4_MABX_B.SFunction1_o25_b = 0.1 * ( ((real_T) CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 46) {

              /* ...... "tr5_lateral_position" (14|10, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

              CAN_Sgn.SignedSgn = ((UInt32)CAN_Sgn.SignedSgn) >> 6;

              CAN_Sgn.SignedSgn &= 0x000003FF;

              if (CAN_Sgn.SignedSgn >> 9) {

                CAN_Sgn.SignedSgn |= 0xFFFFFC00;

              }



              L4_MABX_B.SFunction1_o26_l = 0.1 * ( ((real_T) CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 54) {

              /* ...... "tr6_lateral_position" (14|10, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

              CAN_Sgn.SignedSgn = ((UInt32)CAN_Sgn.SignedSgn) >> 6;

              CAN_Sgn.SignedSgn &= 0x000003FF;

              if (CAN_Sgn.SignedSgn >> 9) {

                CAN_Sgn.SignedSgn |= 0xFFFFFC00;

              }



              L4_MABX_B.SFunction1_o27_h = 0.1 * ( ((real_T) CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 62) {

              /* ...... "tr7_lateral_position" (14|10, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

              CAN_Sgn.SignedSgn = ((UInt32)CAN_Sgn.SignedSgn) >> 6;

              CAN_Sgn.SignedSgn &= 0x000003FF;

              if (CAN_Sgn.SignedSgn >> 9) {

                CAN_Sgn.SignedSgn |= 0xFFFFFC00;

              }



              L4_MABX_B.SFunction1_o28_f = 0.1 * ( ((real_T) CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 70) {

              /* ...... "tr8_lateral_position" (14|10, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

              CAN_Sgn.SignedSgn = ((UInt32)CAN_Sgn.SignedSgn) >> 6;

              CAN_Sgn.SignedSgn &= 0x000003FF;

              if (CAN_Sgn.SignedSgn >> 9) {

                CAN_Sgn.SignedSgn |= 0xFFFFFC00;

              }



              L4_MABX_B.SFunction1_o29 = 0.1 * ( ((real_T) CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 78) {

              /* ...... "tr9_lateral_position" (14|10, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

              CAN_Sgn.SignedSgn = ((UInt32)CAN_Sgn.SignedSgn) >> 6;

              CAN_Sgn.SignedSgn &= 0x000003FF;

              if (CAN_Sgn.SignedSgn >> 9) {

                CAN_Sgn.SignedSgn |= 0xFFFFFC00;

              }



              L4_MABX_B.SFunction1_o30 = 0.1 * ( ((real_T) CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 4) {

              /* ...... "tr0_range" (16|16, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

              L4_MABX_B.SFunction1_o31 = 0.01 * ( ((real_T) CAN_Sgn.UnsignedSgn)

                );

            }



            if (modeSignal == 12) {

              /* ...... "tr1_range" (16|16, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

              L4_MABX_B.SFunction1_o32 = 0.01 * ( ((real_T) CAN_Sgn.UnsignedSgn)

                );

            }



            if (modeSignal == 20) {

              /* ...... "tr2_range" (16|16, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

              L4_MABX_B.SFunction1_o33 = 0.01 * ( ((real_T) CAN_Sgn.UnsignedSgn)

                );

            }



            if (modeSignal == 28) {

              /* ...... "tr3_range" (16|16, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

              L4_MABX_B.SFunction1_o34 = 0.01 * ( ((real_T) CAN_Sgn.UnsignedSgn)

                );

            }



            if (modeSignal == 36) {

              /* ...... "tr4_range" (16|16, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

              L4_MABX_B.SFunction1_o35 = 0.01 * ( ((real_T) CAN_Sgn.UnsignedSgn)

                );

            }



            if (modeSignal == 44) {

              /* ...... "tr5_range" (16|16, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

              L4_MABX_B.SFunction1_o36 = 0.01 * ( ((real_T) CAN_Sgn.UnsignedSgn)

                );

            }



            if (modeSignal == 52) {

              /* ...... "tr6_range" (16|16, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

              L4_MABX_B.SFunction1_o37 = 0.01 * ( ((real_T) CAN_Sgn.UnsignedSgn)

                );

            }



            if (modeSignal == 60) {

              /* ...... "tr7_range" (16|16, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

              L4_MABX_B.SFunction1_o38 = 0.01 * ( ((real_T) CAN_Sgn.UnsignedSgn)

                );

            }



            if (modeSignal == 68) {

              /* ...... "tr8_range" (16|16, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

              L4_MABX_B.SFunction1_o39 = 0.01 * ( ((real_T) CAN_Sgn.UnsignedSgn)

                );

            }



            if (modeSignal == 76) {

              /* ...... "tr9_range" (16|16, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

              L4_MABX_B.SFunction1_o40 = 0.01 * ( ((real_T) CAN_Sgn.UnsignedSgn)

                );

            }



            if (modeSignal == 6) {

              /* ...... "tr0_radar_confidence" (24|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o41 = 0.00392156862745098 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) );

            }



            if (modeSignal == 14) {

              /* ...... "tr1_radar_confidence" (24|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o42 = 0.00392156862745098 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) );

            }



            if (modeSignal == 22) {

              /* ...... "tr2_radar_confidence" (24|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o43 = 0.00392156862745098 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) );

            }



            if (modeSignal == 30) {

              /* ...... "tr3_radar_confidence" (24|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o44 = 0.00392156862745098 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) );

            }



            if (modeSignal == 38) {

              /* ...... "tr4_radar_confidence" (24|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o45 = 0.00392156862745098 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) );

            }



            if (modeSignal == 46) {

              /* ...... "tr5_radar_confidence" (24|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o46 = 0.00392156862745098 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) );

            }



            if (modeSignal == 54) {

              /* ...... "tr6_radar_confidence" (24|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o47 = 0.00392156862745098 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) );

            }



            if (modeSignal == 62) {

              /* ...... "tr7_radar_confidence" (24|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o48 = 0.00392156862745098 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) );

            }



            if (modeSignal == 70) {

              /* ...... "tr8_radar_confidence" (24|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o49 = 0.00392156862745098 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) );

            }



            if (modeSignal == 78) {

              /* ...... "tr9_radar_confidence" (24|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o50 = 0.00392156862745098 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) );

            }



            if (modeSignal == 4) {

              /* ...... "tr0_relative_velocitiy" (32|14, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[2];

              CAN_Sgn.SignedSgn &= 0x00003FFF;

              if (CAN_Sgn.SignedSgn >> 13) {

                CAN_Sgn.SignedSgn |= 0xFFFFC000;

              }



              L4_MABX_B.SFunction1_o51 = 0.01 * ( ((real_T) CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 5) {

              /* ...... "tr0_acceleration_over_ground" (32|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o52 = -8.8 + ( 0.05 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) ) );

            }



            if (modeSignal == 12) {

              /* ...... "tr1_relative_velocitiy" (32|14, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[2];

              CAN_Sgn.SignedSgn &= 0x00003FFF;

              if (CAN_Sgn.SignedSgn >> 13) {

                CAN_Sgn.SignedSgn |= 0xFFFFC000;

              }



              L4_MABX_B.SFunction1_o53 = 0.01 * ( ((real_T) CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 13) {

              /* ...... "tr1_acceleration_over_ground" (32|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o54 = -8.8 + ( 0.05 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) ) );

            }



            if (modeSignal == 20) {

              /* ...... "tr2_relative_velocitiy" (32|14, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[2];

              CAN_Sgn.SignedSgn &= 0x00003FFF;

              if (CAN_Sgn.SignedSgn >> 13) {

                CAN_Sgn.SignedSgn |= 0xFFFFC000;

              }



              L4_MABX_B.SFunction1_o55 = 0.01 * ( ((real_T) CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 21) {

              /* ...... "tr2_acceleration_over_ground" (32|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o56 = -8.8 + ( 0.05 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) ) );

            }



            if (modeSignal == 28) {

              /* ...... "tr3_relative_velocitiy" (32|14, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[2];

              CAN_Sgn.SignedSgn &= 0x00003FFF;

              if (CAN_Sgn.SignedSgn >> 13) {

                CAN_Sgn.SignedSgn |= 0xFFFFC000;

              }



              L4_MABX_B.SFunction1_o57 = 0.01 * ( ((real_T) CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 29) {

              /* ...... "tr3_acceleration_over_ground" (32|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o58 = -8.8 + ( 0.05 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) ) );

            }



            if (modeSignal == 36) {

              /* ...... "tr4_relative_velocitiy" (32|14, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[2];

              CAN_Sgn.SignedSgn &= 0x00003FFF;

              if (CAN_Sgn.SignedSgn >> 13) {

                CAN_Sgn.SignedSgn |= 0xFFFFC000;

              }



              L4_MABX_B.SFunction1_o59 = 0.01 * ( ((real_T) CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 37) {

              /* ...... "tr4_acceleration_over_ground" (32|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o60 = -8.8 + ( 0.05 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) ) );

            }



            if (modeSignal == 44) {

              /* ...... "tr5_relative_velocitiy" (32|14, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[2];

              CAN_Sgn.SignedSgn &= 0x00003FFF;

              if (CAN_Sgn.SignedSgn >> 13) {

                CAN_Sgn.SignedSgn |= 0xFFFFC000;

              }



              L4_MABX_B.SFunction1_o61 = 0.01 * ( ((real_T) CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 45) {

              /* ...... "tr5_acceleration_over_ground" (32|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o62 = -8.8 + ( 0.05 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) ) );

            }



            if (modeSignal == 52) {

              /* ...... "tr6_relative_velocitiy" (32|14, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[2];

              CAN_Sgn.SignedSgn &= 0x00003FFF;

              if (CAN_Sgn.SignedSgn >> 13) {

                CAN_Sgn.SignedSgn |= 0xFFFFC000;

              }



              L4_MABX_B.SFunction1_o63 = 0.01 * ( ((real_T) CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 53) {

              /* ...... "tr6_acceleration_over_ground" (32|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o64 = -8.8 + ( 0.05 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) ) );

            }



            if (modeSignal == 60) {

              /* ...... "tr7_relative_velocitiy" (32|14, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[2];

              CAN_Sgn.SignedSgn &= 0x00003FFF;

              if (CAN_Sgn.SignedSgn >> 13) {

                CAN_Sgn.SignedSgn |= 0xFFFFC000;

              }



              L4_MABX_B.SFunction1_o65 = 0.01 * ( ((real_T) CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 61) {

              /* ...... "tr7_acceleration_over_ground" (32|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o66 = -8.8 + ( 0.05 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) ) );

            }



            if (modeSignal == 68) {

              /* ...... "tr8_relative_velocitiy" (32|14, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[2];

              CAN_Sgn.SignedSgn &= 0x00003FFF;

              if (CAN_Sgn.SignedSgn >> 13) {

                CAN_Sgn.SignedSgn |= 0xFFFFC000;

              }



              L4_MABX_B.SFunction1_o67 = 0.01 * ( ((real_T) CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 69) {

              /* ...... "tr8_acceleration_over_ground" (32|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o68 = -8.8 + ( 0.05 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) ) );

            }



            if (modeSignal == 76) {

              /* ...... "tr9_relative_velocitiy" (32|14, mode-dependent signal, signed int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[2];

              CAN_Sgn.SignedSgn &= 0x00003FFF;

              if (CAN_Sgn.SignedSgn >> 13) {

                CAN_Sgn.SignedSgn |= 0xFFFFC000;

              }



              L4_MABX_B.SFunction1_o69 = 0.01 * ( ((real_T) CAN_Sgn.SignedSgn) );

            }



            if (modeSignal == 77) {

              /* ...... "tr9_acceleration_over_ground" (32|8, mode-dependent signal, unsigned int, motorola back.) */

              CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

              CAN_Sgn.UnsignedSgn &= 0x000000FF;

              L4_MABX_B.SFunction1_o70 = -8.8 + ( 0.05 * ( ((real_T)

                CAN_Sgn.UnsignedSgn) ) );

            }

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o72 = 0.0;

      }

    }

  }



  /* End of Constant: '<S434>/Constant' */

  /* End of Outputs for SubSystem: '<S509>/Tracks' */



  /* DataTypeConversion: '<S509>/Data Type Conversion10' */

  L4_MABX_B.Bendix_RADAR_Tracks_RX_delta_ti = L4_MABX_B.SFunction1_o74;



  /* DataTypeConversion: '<S509>/Data Type Conversion8' */

  L4_MABX_B.Bendix_RADAR_Tracks_RX_status = (L4_MABX_B.SFunction1_o72 != 0.0);



  /* DataTypeConversion: '<S509>/Data Type Conversion9' */

  L4_MABX_B.Bendix_RADAR_Tracks_RX_time = L4_MABX_B.SFunction1_o73;



  /* DataTypeConversion: '<S511>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_i = L4_MABX_B.SFunction1_o23_o;



  /* DataTypeConversion: '<S511>/Data Type Conversion8' */

  L4_MABX_B.RX_status_ln = (L4_MABX_B.SFunction1_o21_j != 0.0);



  /* DataTypeConversion: '<S511>/Data Type Conversion9' */

  L4_MABX_B.RX_time_nv = L4_MABX_B.SFunction1_o22_oy;



  /* DataTypeConversion: '<S513>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_n = L4_MABX_B.SFunction1_o23_i;



  /* DataTypeConversion: '<S513>/Data Type Conversion8' */

  L4_MABX_B.RX_status_ed = (L4_MABX_B.SFunction1_o21_e != 0.0);



  /* DataTypeConversion: '<S513>/Data Type Conversion9' */

  L4_MABX_B.RX_time_j = L4_MABX_B.SFunction1_o22_ih;



  /* Switch: '<S515>/Switch' */

  if (L4_MABX_B.RX_status_e) {

    L4_MABX_B.RX_status_aq = L4_MABX_B.RX_status_e;

  } else {

    /* DataTypeConversion: '<S515>/Data Type Conversion1' */

    L4_MABX_B.RX_status_jm = (L4_MABX_B.SFunction1_o5_f1p != 0.0);

    L4_MABX_B.RX_status_aq = L4_MABX_B.RX_status_jm;

  }



  if (L4_MABX_B.RX_status_e) {

    /* DataTypeConversion: '<S515>/Data Type Conversion9' */

    L4_MABX_B.RX_time_aa = L4_MABX_B.SFunction1_o6_ez;

    L4_MABX_B.RX_time_a = L4_MABX_B.RX_time_aa;



    /* DataTypeConversion: '<S515>/Data Type Conversion10' */

    L4_MABX_B.RX_delta_time_hb = L4_MABX_B.SFunction1_o7_j;

    L4_MABX_B.RX_delta_time_cn = L4_MABX_B.RX_delta_time_hb;

  } else {

    /* DataTypeConversion: '<S515>/Data Type Conversion2' */

    L4_MABX_B.RX_time_kx = L4_MABX_B.SFunction1_o6_f;

    L4_MABX_B.RX_time_a = L4_MABX_B.RX_time_kx;



    /* DataTypeConversion: '<S515>/Data Type Conversion3' */

    L4_MABX_B.RX_delta_time_ga = L4_MABX_B.SFunction1_o7_bu;

    L4_MABX_B.RX_delta_time_cn = L4_MABX_B.RX_delta_time_ga;

  }



  /* DataTypeConversion: '<S518>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_kz = L4_MABX_B.SFunction1_o4_ha;



  /* DataTypeConversion: '<S518>/Data Type Conversion8' */

  L4_MABX_B.RX_status_d = (L4_MABX_B.SFunction1_o2_bq != 0.0);



  /* DataTypeConversion: '<S518>/Data Type Conversion9' */

  L4_MABX_B.RX_time_no = L4_MABX_B.SFunction1_o3_dd;



  /* Outputs for Enabled SubSystem: '<S520>/EBC1_0B' incorporates:

   *  EnablePort: '<S521>/Enable'

   */

  /* Constant: '<S439>/Constant1' */

  if (L4_MABX_P.Constant1_Value_nx) {

    /* S-Function (rti_commonblock): '<S521>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "EBC1_0B" Id:418382091 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F0010B].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F0010B].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o23_n = 1.0;

        L4_MABX_B.SFunction1_o24_o = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F0010B].timestamp;

        L4_MABX_B.SFunction1_o25_m = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F0010B].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18F0010B].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "ASREngCtrlActive" (0|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o1_bq = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ASRBrakeCtrlActive" (2|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o2_pl3 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "AntiLockBrakingActive" (4|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o3_bzd = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EBSBrakeSwitch" (6|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o4_cj = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "BrakePedalPos" (8|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o5_a = 0.4 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "ABSOffroadSwitch" (16|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o6_nt = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ASROffroadSwitch" (18|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o7_lm = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ASRHillHolderSwitch" (20|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o8_n5 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "TractionCtrlOverrideSwitch" (22|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o9_dw = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "AccelInterlockSwitch" (24|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o10_by = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EngDerateSwitch" (26|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o11_m = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EngAuxShutdownSwitch" (28|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o12_l = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "RemoteAccelEnableSwitch" (30|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o13_d = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EngRetarderSelection" (32|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o14_n = 0.4 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "ABSFullyOperational" (40|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o15_a0 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EBSRedWarningSignal" (42|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o16_k = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ABS_EBSAmberWarningSignal" (44|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o17_j = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ATC_ASRInformationSignal" (46|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o18_d = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SrcAddrssOfCtrllngDvcFrBrkCntrl" (48|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o19_k = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "HaltBrakeSwitch" (58|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o20_h = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "TrailerABSStatus" (60|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o21_l = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "TrctrMntdTrilerABSWarningSignal" (62|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o22_i = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o23_n = 0.0;

      }

    }

  }



  /* End of Constant: '<S439>/Constant1' */

  /* End of Outputs for SubSystem: '<S520>/EBC1_0B' */



  /* DataTypeConversion: '<S520>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_m = L4_MABX_B.SFunction1_o25_m;



  /* DataTypeConversion: '<S520>/Data Type Conversion8' */

  L4_MABX_B.RX_status_b = (L4_MABX_B.SFunction1_o23_n != 0.0);



  /* DataTypeConversion: '<S520>/Data Type Conversion9' */

  L4_MABX_B.RX_time_ih = L4_MABX_B.SFunction1_o24_o;



  /* DataTypeConversion: '<S522>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_nf = L4_MABX_B.SFunction1_o25_p;



  /* DataTypeConversion: '<S522>/Data Type Conversion8' */

  L4_MABX_B.RX_status_g2 = (L4_MABX_B.SFunction1_o23_b != 0.0);



  /* DataTypeConversion: '<S522>/Data Type Conversion9' */

  L4_MABX_B.RX_time_an = L4_MABX_B.SFunction1_o24_l;



  /* DataTypeConversion: '<S524>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_ja = L4_MABX_B.SFunction1_o10_pk;



  /* DataTypeConversion: '<S524>/Data Type Conversion8' */

  L4_MABX_B.RX_status_n = (L4_MABX_B.SFunction1_o8_bo != 0.0);



  /* DataTypeConversion: '<S524>/Data Type Conversion9' */

  L4_MABX_B.RX_time_c = L4_MABX_B.SFunction1_o9_a;



  /* DataTypeConversion: '<S571>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_ne = L4_MABX_B.SFunction1_o11_b;



  /* DataTypeConversion: '<S571>/Data Type Conversion8' */

  L4_MABX_B.RX_status_h5 = (L4_MABX_B.SFunction1_o9_gn != 0.0);



  /* DataTypeConversion: '<S571>/Data Type Conversion9' */

  L4_MABX_B.RX_time_f = L4_MABX_B.SFunction1_o10_b;



  /* Outputs for Enabled SubSystem: '<S573>/EEC2_001' incorporates:

   *  EnablePort: '<S574>/Enable'

   */

  /* Constant: '<S444>/Enable_RX_EEC2_00' */

  if (L4_MABX_P.Enable_RX_EEC2_00_Value) {

    /* S-Function (rti_commonblock): '<S574>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "EEC2_00" Id:217056000 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0xCF00300].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0xCF00300].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o15_d = 1.0;

        L4_MABX_B.SFunction1_o16_e = (real_T)

          can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0xCF00300].timestamp;

        L4_MABX_B.SFunction1_o17_l = (real_T)

          can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0xCF00300].deltatime;

        CAN_Msg = can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0xCF00300].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "SPN558_AccelPed1LowIdlSwitch" (0|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o1_a0 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN559_AccelPedKickdownSw" (2|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o2_m4 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN1437_RoadSpeedLimitStatus" (4|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o3_k = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN2970_AccelPed2LowIdlSwitch" (6|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o4_nu = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN91_AccelPedPos1" (8|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o5_e0 = 0.4 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "SPN92_EngPercLoadAtCurrSpd" (16|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o6_j = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN974_RemAccelPedalPosition" (24|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o7_b = 0.4 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "SPN29_AccelPedPos2" (32|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o8_py = 0.4 * ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "SPN2979_VehAccelRateLimStatus" (40|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o9_iy = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN5021_MomEngMaxPwrEnFdbk" (42|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o10_m = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN5399_DPFThermMgmtActive" (44|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o11_c = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN5400_SCRThermMgmtActive" (46|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 6;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o12_i = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "SPN3357_ActMaxAvailEngPercTrq" (48|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o13_gy = 0.4 * ( ((real_T) CAN_Sgn.UnsignedSgn)

              );



            /* ...... "SPN5398_EstPumpingPercentTorque" (56|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o14_g = -125 + ( ((real_T) CAN_Sgn.UnsignedSgn)

              );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o15_d = 0.0;

      }

    }

  }



  /* End of Constant: '<S444>/Enable_RX_EEC2_00' */

  /* End of Outputs for SubSystem: '<S573>/EEC2_001' */



  /* DataTypeConversion: '<S573>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_b = L4_MABX_B.SFunction1_o17_l;



  /* DataTypeConversion: '<S573>/Data Type Conversion8' */

  L4_MABX_B.RX_status_nu = (L4_MABX_B.SFunction1_o15_d != 0.0);



  /* DataTypeConversion: '<S573>/Data Type Conversion9' */

  L4_MABX_B.RX_time_d = L4_MABX_B.SFunction1_o16_e;



  /* DataTypeConversion: '<S575>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_g = L4_MABX_B.SFunction1_o5_jl;



  /* DataTypeConversion: '<S575>/Data Type Conversion8' */

  L4_MABX_B.RX_status_j = (L4_MABX_B.SFunction1_o3_fy != 0.0);



  /* DataTypeConversion: '<S575>/Data Type Conversion9' */

  L4_MABX_B.RX_time_n0 = L4_MABX_B.SFunction1_o4_lo;



  /* DataTypeConversion: '<S577>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_kx = L4_MABX_B.SFunction1_o6_o;



  /* DataTypeConversion: '<S577>/Data Type Conversion8' */

  L4_MABX_B.RX_status_c4 = (L4_MABX_B.SFunction1_o4_ly != 0.0);



  /* DataTypeConversion: '<S577>/Data Type Conversion9' */

  L4_MABX_B.RX_time_o = L4_MABX_B.SFunction1_o5_e3;



  /* Switch: '<S579>/Switch' */

  if (L4_MABX_B.RX_status_h) {

    L4_MABX_B.SID_p = L4_MABX_B.SFunction1_o1_hs;

    L4_MABX_B.SetMode = L4_MABX_B.SFunction1_o2_d0;

    L4_MABX_B.OpMode = L4_MABX_B.SFunction1_o3_o4;

    L4_MABX_B.VDOP = L4_MABX_B.SFunction1_o5_nf;

    L4_MABX_B.TDOP = L4_MABX_B.SFunction1_o6_g4y;

    L4_MABX_B.RX_status_kh = L4_MABX_B.RX_status_h;

  } else {

    L4_MABX_B.SID_p = L4_MABX_B.SFunction1_o1_lx;

    L4_MABX_B.SetMode = L4_MABX_B.SFunction1_o2_ad5;

    L4_MABX_B.OpMode = L4_MABX_B.SFunction1_o3_g5;

    L4_MABX_B.VDOP = L4_MABX_B.SFunction1_o5_lw;

    L4_MABX_B.TDOP = L4_MABX_B.SFunction1_o6_nk;



    /* DataTypeConversion: '<S579>/Data Type Conversion3' */

    L4_MABX_B.RX_status_gi = (L4_MABX_B.SFunction1_o7_ev != 0.0);

    L4_MABX_B.RX_status_kh = L4_MABX_B.RX_status_gi;

  }



  if (L4_MABX_B.RX_status_h) {

    /* DataTypeConversion: '<S579>/Data Type Conversion9' */

    L4_MABX_B.RX_time_ml = L4_MABX_B.SFunction1_o8_es;

    L4_MABX_B.RX_time_le = L4_MABX_B.RX_time_ml;



    /* DataTypeConversion: '<S579>/Data Type Conversion10' */

    L4_MABX_B.RX_delta_time_fl = L4_MABX_B.SFunction1_o9_gd;

    L4_MABX_B.RX_delta_time_ms = L4_MABX_B.RX_delta_time_fl;

  } else {

    /* DataTypeConversion: '<S579>/Data Type Conversion2' */

    L4_MABX_B.RX_time_d1 = L4_MABX_B.SFunction1_o8_lx;

    L4_MABX_B.RX_time_le = L4_MABX_B.RX_time_d1;



    /* DataTypeConversion: '<S579>/Data Type Conversion1' */

    L4_MABX_B.RX_delta_time_iw = L4_MABX_B.SFunction1_o9_d;

    L4_MABX_B.RX_delta_time_ms = L4_MABX_B.RX_delta_time_iw;

  }



  /* DataTypeConversion: '<S582>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_jj = L4_MABX_B.SFunction1_o7_cp;



  /* DataTypeConversion: '<S582>/Data Type Conversion8' */

  L4_MABX_B.RX_status_f = (L4_MABX_B.SFunction1_o5_ij != 0.0);



  /* DataTypeConversion: '<S582>/Data Type Conversion9' */

  L4_MABX_B.RX_time_h = L4_MABX_B.SFunction1_o6_kk;



  /* Switch: '<S449>/Switch' */

  if (L4_MABX_B.Operator_nc) {

    ReAX_EchoedSteerWheelPos = L4_MABX_B.SFunction1_o2_jnu;



    /* DataTypeConversion: '<S584>/Data Type Conversion8' */

    L4_MABX_B.RX_status_og = (L4_MABX_B.SFunction1_o3_pv != 0.0);

    L4_MABX_B.RX_status_n4 = L4_MABX_B.RX_status_og;



    /* DataTypeConversion: '<S584>/Data Type Conversion9' */

    L4_MABX_B.RX_time_ob = L4_MABX_B.SFunction1_o4_c;

    L4_MABX_B.RX_time_l4 = L4_MABX_B.RX_time_ob;



    /* DataTypeConversion: '<S584>/Data Type Conversion10' */

    L4_MABX_B.RX_delta_time_a5 = L4_MABX_B.SFunction1_o5_ni;

    L4_MABX_B.RX_delta_time_n5 = L4_MABX_B.RX_delta_time_a5;

  } else {

    ReAX_EchoedSteerWheelPos = L4_MABX_B.SFunction1_o2_g5;



    /* DataTypeConversion: '<S585>/Data Type Conversion8' */

    L4_MABX_B.RX_status_kul = (L4_MABX_B.SFunction1_o3_l1 != 0.0);

    L4_MABX_B.RX_status_n4 = L4_MABX_B.RX_status_kul;



    /* DataTypeConversion: '<S585>/Data Type Conversion9' */

    L4_MABX_B.RX_time_ks = L4_MABX_B.SFunction1_o4_k1;

    L4_MABX_B.RX_time_l4 = L4_MABX_B.RX_time_ks;



    /* DataTypeConversion: '<S585>/Data Type Conversion10' */

    L4_MABX_B.RX_delta_time_iq = L4_MABX_B.SFunction1_o5_j;

    L4_MABX_B.RX_delta_time_n5 = L4_MABX_B.RX_delta_time_iq;

  }



  /* RelationalOperator: '<S621>/Operator' incorporates:

   *  Constant: '<S452>/Constant'

   *  Constant: '<S617>/Constant'

   */

  L4_MABX_B.Operator_k5 = (CANR_PROPB_XPR_1_50_CHANNEL_APV ==

    L4_MABX_P.Constant_Value_p0);



  /* Outputs for Enabled SubSystem: '<S614>/CAN_TYPE1_RX_M1_C1' incorporates:

   *  EnablePort: '<S618>/Enable'

   */

  if (L4_MABX_B.Operator_k5) {

    /* S-Function (rti_commonblock): '<S618>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "PropB_XPR_1" Id:419387472 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FF5850].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FF5850].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o3_jj = 1.0;

        L4_MABX_B.SFunction1_o4_i = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FF5850].timestamp;

        L4_MABX_B.SFunction1_o5_k = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FF5850].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FF5850].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "EPBPCMInhibitStatusFeedback" (0|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o1_nn = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EPBPCMManualStatusFeedback" (2|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o2_pn = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o3_jj = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S614>/CAN_TYPE1_RX_M1_C1' */



  /* RelationalOperator: '<S622>/Operator' incorporates:

   *  Constant: '<S452>/Constant'

   *  Constant: '<S617>/Constant1'

   */

  L4_MABX_B.Operator_j1 = (CANR_PROPB_XPR_1_50_CHANNEL_APV ==

    L4_MABX_P.Constant1_Value_j2);



  /* Outputs for Enabled SubSystem: '<S615>/CAN_TYPE1_RX_M1_C2' incorporates:

   *  EnablePort: '<S619>/Enable'

   */

  if (L4_MABX_B.Operator_j1) {

    /* S-Function (rti_commonblock): '<S619>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "PropB_XPR_1" Id:419387472 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FF5850].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FF5850].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o3_gz = 1.0;

        L4_MABX_B.SFunction1_o4_hf3 = (real_T)

          can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FF5850].timestamp;

        L4_MABX_B.SFunction1_o5_p5 = (real_T)

          can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FF5850].deltatime;

        CAN_Msg = can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FF5850].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "EPBPCMInhibitStatusFeedback" (0|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o1_lae = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EPBPCMManualStatusFeedback" (2|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o2_bh = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o3_gz = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S615>/CAN_TYPE1_RX_M1_C2' */



  /* RelationalOperator: '<S623>/Operator' incorporates:

   *  Constant: '<S452>/Constant'

   *  Constant: '<S617>/Constant2'

   */

  L4_MABX_B.Operator_g3 = (CANR_PROPB_XPR_1_50_CHANNEL_APV ==

    L4_MABX_P.Constant2_Value_j);



  /* Outputs for Enabled SubSystem: '<S616>/CAN_TYPE1_RX_M2_C1' incorporates:

   *  EnablePort: '<S620>/Enable'

   */

  if (L4_MABX_B.Operator_g3) {

    /* S-Function (rti_commonblock): '<S620>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "PropB_XPR_1" Id:419387472 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M2_C1_XTD[CANTP1_M2_C1_RXSRVC_XTD_0x18FF5850].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M2_C1_XTD[CANTP1_M2_C1_RXSRVC_XTD_0x18FF5850].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o3_p = 1.0;

        L4_MABX_B.SFunction1_o4_au = (real_T)

          can_type1_M2_C1_XTD[CANTP1_M2_C1_RXSRVC_XTD_0x18FF5850].timestamp;

        L4_MABX_B.SFunction1_o5_ne = (real_T)

          can_type1_M2_C1_XTD[CANTP1_M2_C1_RXSRVC_XTD_0x18FF5850].deltatime;

        CAN_Msg = can_type1_M2_C1_XTD[CANTP1_M2_C1_RXSRVC_XTD_0x18FF5850].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "EPBPCMInhibitStatusFeedback" (0|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o1_n0 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "EPBPCMManualStatusFeedback" (2|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o2_fk = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o3_p = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S616>/CAN_TYPE1_RX_M2_C1' */



  /* DataTypeConversion: '<S616>/Data Type Conversion' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o1_n0;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion_hv = starting_index;



  /* End of DataTypeConversion: '<S616>/Data Type Conversion' */



  /* DataTypeConversion: '<S616>/Data Type Conversion2' */

  L4_MABX_B.EPBPCMInhibitStatusFeedback = (ENUM_XPR_FEEDBACK_T)

    L4_MABX_B.DataTypeConversion_hv;



  /* MultiPortSwitch: '<S452>/Multiport_Switch' incorporates:

   *  Constant: '<S452>/Constant'

   */

  switch (CANR_PROPB_XPR_1_50_CHANNEL_APV) {

   case ENUM_CAN_RX_T_RX_CAN_1:

    /* DataTypeConversion: '<S614>/Data Type Conversion' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o1_nn;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion_pd = starting_index;



    /* End of DataTypeConversion: '<S614>/Data Type Conversion' */



    /* DataTypeConversion: '<S614>/Data Type Conversion2' */

    L4_MABX_B.EPBPCMInhibitStatusFeedback_g = (ENUM_XPR_FEEDBACK_T)

      L4_MABX_B.DataTypeConversion_pd;

    L4_MABX_B.EPBPCMInhibitStatusFeedback_i =

      L4_MABX_B.EPBPCMInhibitStatusFeedback_g;

    break;



   case ENUM_CAN_RX_T_RX_CAN_2:

    /* DataTypeConversion: '<S615>/Data Type Conversion' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o1_lae;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion_ai = starting_index;



    /* End of DataTypeConversion: '<S615>/Data Type Conversion' */



    /* DataTypeConversion: '<S615>/Data Type Conversion2' */

    L4_MABX_B.EPBPCMInhibitStatusFeedback_k = (ENUM_XPR_FEEDBACK_T)

      L4_MABX_B.DataTypeConversion_ai;

    L4_MABX_B.EPBPCMInhibitStatusFeedback_i =

      L4_MABX_B.EPBPCMInhibitStatusFeedback_k;

    break;



   case ENUM_CAN_RX_T_RX_CAN_3:

    L4_MABX_B.EPBPCMInhibitStatusFeedback_i =

      L4_MABX_B.EPBPCMInhibitStatusFeedback;

    break;



   case ENUM_CAN_RX_T_RX_CAN_4:

    L4_MABX_B.EPBPCMInhibitStatusFeedback_i =

      L4_MABX_B.EPBPCMInhibitStatusFeedback;

    break;



   case ENUM_CAN_RX_T_RX_CAN_5:

    L4_MABX_B.EPBPCMInhibitStatusFeedback_i =

      L4_MABX_B.EPBPCMInhibitStatusFeedback;

    break;



   case ENUM_CAN_RX_T_RX_CAN_6:

    L4_MABX_B.EPBPCMInhibitStatusFeedback_i =

      L4_MABX_B.EPBPCMInhibitStatusFeedback;

    break;



   default:

    L4_MABX_B.EPBPCMInhibitStatusFeedback_i =

      L4_MABX_B.EPBPCMInhibitStatusFeedback;

    break;

  }



  /* DataTypeConversion: '<S616>/Data Type Conversion1' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o2_fk;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion1_m4 = starting_index;



  /* End of DataTypeConversion: '<S616>/Data Type Conversion1' */



  /* DataTypeConversion: '<S616>/Data Type Conversion3' */

  L4_MABX_B.EPBPCMManualStatusFeedback = (ENUM_XPR_FEEDBACK_T)

    L4_MABX_B.DataTypeConversion1_m4;



  /* MultiPortSwitch: '<S452>/Multiport_Switch' incorporates:

   *  Constant: '<S452>/Constant'

   */

  switch (CANR_PROPB_XPR_1_50_CHANNEL_APV) {

   case ENUM_CAN_RX_T_RX_CAN_1:

    /* DataTypeConversion: '<S614>/Data Type Conversion1' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o2_pn;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion1_ci = starting_index;



    /* End of DataTypeConversion: '<S614>/Data Type Conversion1' */



    /* DataTypeConversion: '<S614>/Data Type Conversion3' */

    L4_MABX_B.EPBPCMManualStatusFeedback_g = (ENUM_XPR_FEEDBACK_T)

      L4_MABX_B.DataTypeConversion1_ci;

    L4_MABX_B.EPBPCMManualStatusFeedback_j =

      L4_MABX_B.EPBPCMManualStatusFeedback_g;

    break;



   case ENUM_CAN_RX_T_RX_CAN_2:

    /* DataTypeConversion: '<S615>/Data Type Conversion1' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o2_bh;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion1_hx = starting_index;



    /* End of DataTypeConversion: '<S615>/Data Type Conversion1' */



    /* DataTypeConversion: '<S615>/Data Type Conversion3' */

    L4_MABX_B.EPBPCMManualStatusFeedback_h = (ENUM_XPR_FEEDBACK_T)

      L4_MABX_B.DataTypeConversion1_hx;

    L4_MABX_B.EPBPCMManualStatusFeedback_j =

      L4_MABX_B.EPBPCMManualStatusFeedback_h;

    break;



   case ENUM_CAN_RX_T_RX_CAN_3:

    L4_MABX_B.EPBPCMManualStatusFeedback_j =

      L4_MABX_B.EPBPCMManualStatusFeedback;

    break;



   case ENUM_CAN_RX_T_RX_CAN_4:

    L4_MABX_B.EPBPCMManualStatusFeedback_j =

      L4_MABX_B.EPBPCMManualStatusFeedback;

    break;



   case ENUM_CAN_RX_T_RX_CAN_5:

    L4_MABX_B.EPBPCMManualStatusFeedback_j =

      L4_MABX_B.EPBPCMManualStatusFeedback;

    break;



   case ENUM_CAN_RX_T_RX_CAN_6:

    L4_MABX_B.EPBPCMManualStatusFeedback_j =

      L4_MABX_B.EPBPCMManualStatusFeedback;

    break;



   default:

    L4_MABX_B.EPBPCMManualStatusFeedback_j =

      L4_MABX_B.EPBPCMManualStatusFeedback;

    break;

  }



  /* DataTypeConversion: '<S616>/Data Type Conversion8' */

  L4_MABX_B.RX_status_m = (L4_MABX_B.SFunction1_o3_p != 0.0);



  /* MultiPortSwitch: '<S452>/Multiport_Switch' incorporates:

   *  Constant: '<S452>/Constant'

   */

  switch (CANR_PROPB_XPR_1_50_CHANNEL_APV) {

   case ENUM_CAN_RX_T_RX_CAN_1:

    /* DataTypeConversion: '<S614>/Data Type Conversion8' */

    L4_MABX_B.RX_status_nm = (L4_MABX_B.SFunction1_o3_jj != 0.0);

    L4_MABX_B.RX_status_dz = L4_MABX_B.RX_status_nm;

    break;



   case ENUM_CAN_RX_T_RX_CAN_2:

    /* DataTypeConversion: '<S615>/Data Type Conversion8' */

    L4_MABX_B.RX_status_on = (L4_MABX_B.SFunction1_o3_gz != 0.0);

    L4_MABX_B.RX_status_dz = L4_MABX_B.RX_status_on;

    break;



   case ENUM_CAN_RX_T_RX_CAN_3:

    L4_MABX_B.RX_status_dz = L4_MABX_B.RX_status_m;

    break;



   case ENUM_CAN_RX_T_RX_CAN_4:

    L4_MABX_B.RX_status_dz = L4_MABX_B.RX_status_m;

    break;



   case ENUM_CAN_RX_T_RX_CAN_5:

    L4_MABX_B.RX_status_dz = L4_MABX_B.RX_status_m;

    break;



   case ENUM_CAN_RX_T_RX_CAN_6:

    L4_MABX_B.RX_status_dz = L4_MABX_B.RX_status_m;

    break;



   default:

    L4_MABX_B.RX_status_dz = L4_MABX_B.RX_status_m;

    break;

  }



  /* DataTypeConversion: '<S616>/Data Type Conversion9' */

  L4_MABX_B.RX_time_fr = L4_MABX_B.SFunction1_o4_au;



  /* MultiPortSwitch: '<S452>/Multiport_Switch' incorporates:

   *  Constant: '<S452>/Constant'

   */

  switch (CANR_PROPB_XPR_1_50_CHANNEL_APV) {

   case ENUM_CAN_RX_T_RX_CAN_1:

    /* DataTypeConversion: '<S614>/Data Type Conversion9' */

    L4_MABX_B.RX_time_gc = L4_MABX_B.SFunction1_o4_i;

    L4_MABX_B.RX_time_dy = L4_MABX_B.RX_time_gc;

    break;



   case ENUM_CAN_RX_T_RX_CAN_2:

    /* DataTypeConversion: '<S615>/Data Type Conversion9' */

    L4_MABX_B.RX_time_lu = L4_MABX_B.SFunction1_o4_hf3;

    L4_MABX_B.RX_time_dy = L4_MABX_B.RX_time_lu;

    break;



   case ENUM_CAN_RX_T_RX_CAN_3:

    L4_MABX_B.RX_time_dy = L4_MABX_B.RX_time_fr;

    break;



   case ENUM_CAN_RX_T_RX_CAN_4:

    L4_MABX_B.RX_time_dy = L4_MABX_B.RX_time_fr;

    break;



   case ENUM_CAN_RX_T_RX_CAN_5:

    L4_MABX_B.RX_time_dy = L4_MABX_B.RX_time_fr;

    break;



   case ENUM_CAN_RX_T_RX_CAN_6:

    L4_MABX_B.RX_time_dy = L4_MABX_B.RX_time_fr;

    break;



   default:

    L4_MABX_B.RX_time_dy = L4_MABX_B.RX_time_fr;

    break;

  }



  /* DataTypeConversion: '<S616>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_h = L4_MABX_B.SFunction1_o5_ne;



  /* MultiPortSwitch: '<S452>/Multiport_Switch' incorporates:

   *  Constant: '<S452>/Constant'

   */

  switch (CANR_PROPB_XPR_1_50_CHANNEL_APV) {

   case ENUM_CAN_RX_T_RX_CAN_1:

    /* DataTypeConversion: '<S614>/Data Type Conversion10' */

    L4_MABX_B.RX_delta_time_drb = L4_MABX_B.SFunction1_o5_k;

    L4_MABX_B.RX_delta_time_at = L4_MABX_B.RX_delta_time_drb;

    break;



   case ENUM_CAN_RX_T_RX_CAN_2:

    /* DataTypeConversion: '<S615>/Data Type Conversion10' */

    L4_MABX_B.RX_delta_time_bu = L4_MABX_B.SFunction1_o5_p5;

    L4_MABX_B.RX_delta_time_at = L4_MABX_B.RX_delta_time_bu;

    break;



   case ENUM_CAN_RX_T_RX_CAN_3:

    L4_MABX_B.RX_delta_time_at = L4_MABX_B.RX_delta_time_h;

    break;



   case ENUM_CAN_RX_T_RX_CAN_4:

    L4_MABX_B.RX_delta_time_at = L4_MABX_B.RX_delta_time_h;

    break;



   case ENUM_CAN_RX_T_RX_CAN_5:

    L4_MABX_B.RX_delta_time_at = L4_MABX_B.RX_delta_time_h;

    break;



   case ENUM_CAN_RX_T_RX_CAN_6:

    L4_MABX_B.RX_delta_time_at = L4_MABX_B.RX_delta_time_h;

    break;



   default:

    L4_MABX_B.RX_delta_time_at = L4_MABX_B.RX_delta_time_h;

    break;

  }



  /* RelationalOperator: '<S624>/Operator' incorporates:

   *  Constant: '<S452>/Constant'

   *  Constant: '<S617>/Constant3'

   */

  L4_MABX_B.Operator_kv = (CANR_PROPB_XPR_1_50_CHANNEL_APV ==

    L4_MABX_P.Constant3_Value_e);



  /* RelationalOperator: '<S625>/Operator' incorporates:

   *  Constant: '<S452>/Constant'

   *  Constant: '<S617>/Constant4'

   */

  L4_MABX_B.Operator_mb = (CANR_PROPB_XPR_1_50_CHANNEL_APV ==

    L4_MABX_P.Constant4_Value_oe);



  /* RelationalOperator: '<S626>/Operator' incorporates:

   *  Constant: '<S452>/Constant'

   *  Constant: '<S617>/Constant5'

   */

  L4_MABX_B.Operator_iz3 = (CANR_PROPB_XPR_1_50_CHANNEL_APV ==

    L4_MABX_P.Constant5_Value_g);



  /* Outputs for Enabled SubSystem: '<S627>/PX2_LaneEdgeLeft' incorporates:

   *  EnablePort: '<S628>/Enable'

   */

  /* Constant: '<S453>/Constant' */

  if (L4_MABX_P.Constant_Value_kr) {

    /* S-Function (rti_commonblock): '<S628>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "PX2_LaneEdgeLeft" Id:770 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x302].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x302].timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o4_fz = 1.0;

        L4_MABX_B.SFunction1_o5_e = (real_T)

          can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x302].timestamp;

        L4_MABX_B.SFunction1_o6_l0 = (real_T)

          can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x302].deltatime;

        CAN_Msg = can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x302].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "PX2_LaneEdgeLeftAngle" (0|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[1];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o1_mj = 0.01 * ( ((real_T) CAN_Sgn.SignedSgn) );



            /* ...... "PX2_LaneEdgeLeftNumPoints" (16|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o2_ls = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "PX2_LaneEdgeLeftPosition" (24|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[4];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o3_c1 = 0.001 * ( ((real_T) CAN_Sgn.SignedSgn) );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o4_fz = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S627>/PX2_LaneEdgeLeft' */



  /* DataTypeConversion: '<S627>/Data Type Conversion1' */

  L4_MABX_B.RX_delta_time_o0 = L4_MABX_B.SFunction1_o6_l0;



  /* DataTypeConversion: '<S627>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_i0 = L4_MABX_B.SFunction1_o7_d;



  /* DataTypeConversion: '<S627>/Data Type Conversion2' */

  L4_MABX_B.RX_status_bx = (L4_MABX_B.SFunction1_o4_fz != 0.0);



  /* DataTypeConversion: '<S627>/Data Type Conversion3' */

  L4_MABX_B.RX_time_jb = L4_MABX_B.SFunction1_o5_e;



  /* Outputs for Enabled SubSystem: '<S627>/PX2_LaneEdgeRight' incorporates:

   *  EnablePort: '<S629>/Enable'

   */

  /* Constant: '<S453>/Constant' */

  if (L4_MABX_P.Constant_Value_kr) {

    /* S-Function (rti_commonblock): '<S629>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "PX2_LaneEdgeRight" Id:771 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x303].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x303].timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o4_dh = 1.0;

        L4_MABX_B.SFunction1_o5_fm = (real_T)

          can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x303].timestamp;

        L4_MABX_B.SFunction1_o6_h = (real_T)

          can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x303].deltatime;

        CAN_Msg = can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x303].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "PX2_LaneEdgeRightAngle" (0|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[1];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o1_i2 = 0.01 * ( ((real_T) CAN_Sgn.SignedSgn) );



            /* ...... "PX2_LaneEdgeRightNumPoints" (16|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o2_dg = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "PX2_LaneEdgeRightPosition" (24|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[4];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o3_ad = 0.001 * ( ((real_T) CAN_Sgn.SignedSgn) );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o4_dh = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S627>/PX2_LaneEdgeRight' */



  /* DataTypeConversion: '<S627>/Data Type Conversion4' */

  L4_MABX_B.RX_delta_time_hh = L4_MABX_B.SFunction1_o6_h;



  /* DataTypeConversion: '<S627>/Data Type Conversion5' */

  L4_MABX_B.RX_status_p1 = (L4_MABX_B.SFunction1_o4_dh != 0.0);



  /* DataTypeConversion: '<S627>/Data Type Conversion6' */

  L4_MABX_B.RX_time_k = L4_MABX_B.SFunction1_o5_fm;



  /* DataTypeConversion: '<S627>/Data Type Conversion8' */

  L4_MABX_B.RX_status_o = (L4_MABX_B.SFunction1_o5_b != 0.0);



  /* DataTypeConversion: '<S627>/Data Type Conversion9' */

  L4_MABX_B.RX_time_n3 = L4_MABX_B.SFunction1_o6_kc;



  /* Switch: '<S631>/Switch' */

  if (L4_MABX_B.If_Then_Else.Switch) {

    /* DataTypeConversion: '<S631>/Data Type Conversion8' */

    L4_MABX_B.RX_status_h0 = (L4_MABX_B.SFunction1_o3_bt != 0.0);

    L4_MABX_B.RX_status_ji = L4_MABX_B.RX_status_h0;



    /* DataTypeConversion: '<S631>/Data Type Conversion9' */

    L4_MABX_B.RX_time_fi = L4_MABX_B.SFunction1_o4_ez;

    L4_MABX_B.RX_time_dr = L4_MABX_B.RX_time_fi;



    /* DataTypeConversion: '<S631>/Data Type Conversion10' */

    L4_MABX_B.RX_delta_time_e = L4_MABX_B.SFunction1_o5_gx;

    L4_MABX_B.RX_delta_time_ia = L4_MABX_B.RX_delta_time_e;

  } else {

    /* DataTypeConversion: '<S631>/Data Type Conversion3' */

    L4_MABX_B.RX_status_mm = (L4_MABX_B.SFunction1_o3_a != 0.0);

    L4_MABX_B.RX_status_ji = L4_MABX_B.RX_status_mm;



    /* DataTypeConversion: '<S631>/Data Type Conversion2' */

    L4_MABX_B.RX_time_e5 = L4_MABX_B.SFunction1_o4_ex;

    L4_MABX_B.RX_time_dr = L4_MABX_B.RX_time_e5;



    /* DataTypeConversion: '<S631>/Data Type Conversion1' */

    L4_MABX_B.RX_delta_time_lo = L4_MABX_B.SFunction1_o5_nb;

    L4_MABX_B.RX_delta_time_ia = L4_MABX_B.RX_delta_time_lo;

  }



  /* DataTypeConversion: '<S634>/Data Type Conversion1' */

  L4_MABX_B.XPR1ControlStatus = L4_MABX_B.SFunction1_o6_a;



  /* DataTypeConversion: '<S634>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_hs = L4_MABX_B.SFunction1_o13_g;



  /* DataTypeConversion: '<S634>/Data Type Conversion2' */

  L4_MABX_B.XPR2ControlStatus = L4_MABX_B.SFunction1_o7_a;



  /* DataTypeConversion: '<S634>/Data Type Conversion3' */

  L4_MABX_B.XPR3ControlStatus = L4_MABX_B.SFunction1_o8_b;



  /* DataTypeConversion: '<S634>/Data Type Conversion8' */

  L4_MABX_B.RX_status_jk = (L4_MABX_B.SFunction1_o11_d != 0.0);



  /* DataTypeConversion: '<S634>/Data Type Conversion9' */

  L4_MABX_B.RX_time_gh = L4_MABX_B.SFunction1_o12_k;



  /* DataTypeConversion: '<S636>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_dq = L4_MABX_B.SFunction1_o10_ha;



  /* DataTypeConversion: '<S636>/Data Type Conversion8' */

  L4_MABX_B.RX_status_oh = (L4_MABX_B.SFunction1_o8_h != 0.0);



  /* DataTypeConversion: '<S636>/Data Type Conversion9' */

  L4_MABX_B.RX_time_e = L4_MABX_B.SFunction1_o9_i;



  /* Outputs for Enabled SubSystem: '<S638>/PX2_MapLaneEgoLeft' incorporates:

   *  EnablePort: '<S639>/Enable'

   */

  /* Constant: '<S457>/CAN_RX-Enable_PX2_MapLaneEgoLeft' */

  if (L4_MABX_P.CAN_RXEnable_PX2_MapLaneEgoLeft) {

    /* S-Function (rti_commonblock): '<S639>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "PX2_MapLaneEgoLeft" Id:1542 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x606].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x606].timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o7_c5 = 1.0;

        L4_MABX_B.SFunction1_o8_e = (real_T)

          can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x606].timestamp;

        L4_MABX_B.SFunction1_o9_g = (real_T)

          can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x606].deltatime;

        CAN_Msg = can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x606].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "PX2_MapLaneNearPos" (0|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[1];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o1_ed = 0.00390625 * ( ((real_T)

              CAN_Sgn.SignedSgn) );



            /* ...... "PX2_MapLaneMidPos" (16|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[3];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o2_iv = 0.00390625 * ( ((real_T)

              CAN_Sgn.SignedSgn) );



            /* ...... "PX2_MapLaneFarPos" (32|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o3_df = 0.00390625 * ( ((real_T)

              CAN_Sgn.SignedSgn) );



            /* ...... "PX2_EgoLaneNearPosValid" (48|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o4_ak = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "PX2_EgoLaneMidPosValid" (50|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o5_f1 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "PX2_EgoLaneFarPosValid" (52|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o6_i = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o7_c5 = 0.0;

      }

    }

  }



  /* End of Constant: '<S457>/CAN_RX-Enable_PX2_MapLaneEgoLeft' */

  /* End of Outputs for SubSystem: '<S638>/PX2_MapLaneEgoLeft' */



  /* DataTypeConversion: '<S638>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_iv = L4_MABX_B.SFunction1_o9_g;



  /* DataTypeConversion: '<S638>/Data Type Conversion8' */

  L4_MABX_B.RX_status_av = (L4_MABX_B.SFunction1_o7_c5 != 0.0);



  /* DataTypeConversion: '<S638>/Data Type Conversion9' */

  L4_MABX_B.RX_time_b = L4_MABX_B.SFunction1_o8_e;



  /* Outputs for Enabled SubSystem: '<S640>/PX2_MapLaneEgoRight' incorporates:

   *  EnablePort: '<S641>/Enable'

   */

  /* Constant: '<S458>/CAN_RX-Enable_PX2_MapLaneEgoLeft' */

  if (L4_MABX_P.CAN_RXEnable_PX2_MapLaneEgoLe_a) {

    /* S-Function (rti_commonblock): '<S641>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "PX2_MapLaneEgoRight" Id:1541 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x605].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x605].timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o7_fg = 1.0;

        L4_MABX_B.SFunction1_o8_a = (real_T)

          can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x605].timestamp;

        L4_MABX_B.SFunction1_o9_k = (real_T)

          can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x605].deltatime;

        CAN_Msg = can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x605].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "PX2_MapLaneNearPos" (0|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[1];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o1_m5 = 0.00390625 * ( ((real_T)

              CAN_Sgn.SignedSgn) );



            /* ...... "PX2_MapLaneMidPos" (16|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[3];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o2_dv = 0.00390625 * ( ((real_T)

              CAN_Sgn.SignedSgn) );



            /* ...... "PX2_MapLaneFarPos" (32|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o3_em = 0.00390625 * ( ((real_T)

              CAN_Sgn.SignedSgn) );



            /* ...... "PX2_EgoLaneNearPosValid" (48|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o4_mn = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "PX2_EgoLaneMidPosValid" (50|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o5_gr = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "PX2_EgoLaneFarPosValid" (52|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o6_n = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o7_fg = 0.0;

      }

    }

  }



  /* End of Constant: '<S458>/CAN_RX-Enable_PX2_MapLaneEgoLeft' */

  /* End of Outputs for SubSystem: '<S640>/PX2_MapLaneEgoRight' */



  /* DataTypeConversion: '<S640>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_dr = L4_MABX_B.SFunction1_o9_k;



  /* DataTypeConversion: '<S640>/Data Type Conversion8' */

  L4_MABX_B.RX_status_kd = (L4_MABX_B.SFunction1_o7_fg != 0.0);



  /* DataTypeConversion: '<S640>/Data Type Conversion9' */

  L4_MABX_B.RX_time_fs = L4_MABX_B.SFunction1_o8_a;



  /* Outputs for Enabled SubSystem: '<S642>/PX2_EgoLanePos' incorporates:

   *  EnablePort: '<S643>/Enable'

   */

  /* Constant: '<S459>/Constant' */

  if (L4_MABX_P.Constant_Value_ij) {

    /* S-Function (rti_commonblock): '<S643>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "PX2_EgoLanePos" Id:1540 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x604].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x604].timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o7_l = 1.0;

        L4_MABX_B.SFunction1_o8_n = (real_T)

          can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x604].timestamp;

        L4_MABX_B.SFunction1_o9_c = (real_T)

          can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x604].deltatime;

        CAN_Msg = can_type1_M3_C2_STD[CANTP1_M3_C2_RXSRVC_STD_0x604].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "PX2_EgoLaneNearPosErr" (0|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[1];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o1_kz = 0.1 * ( ((real_T) CAN_Sgn.SignedSgn) );



            /* ...... "PX2_EgoLaneMidPosErr" (16|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[3];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o2_bb = 0.1 * ( ((real_T) CAN_Sgn.SignedSgn) );



            /* ...... "PX2_EgoLaneFarPosErr" (32|16, standard signal, signed int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

            CAN_Sgn.SignedSgn &= 0x0000FFFF;

            if (CAN_Sgn.SignedSgn >> 15) {

              CAN_Sgn.SignedSgn |= 0xFFFF0000;

            }



            L4_MABX_B.SFunction1_o3_n = 0.1 * ( ((real_T) CAN_Sgn.SignedSgn) );



            /* ...... "PX2_EgoLaneNearPosValid" (48|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o4_gq = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "PX2_EgoLaneMidPosValid" (50|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 2;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o5_p = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "PX2_EgoLaneFarPosValid" (52|2, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) >> 4;

            CAN_Sgn.UnsignedSgn &= 0x00000003;

            L4_MABX_B.SFunction1_o6_g = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o7_l = 0.0;

      }

    }

  }



  /* End of Constant: '<S459>/Constant' */

  /* End of Outputs for SubSystem: '<S642>/PX2_EgoLanePos' */



  /* DataTypeConversion: '<S642>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_jag = L4_MABX_B.SFunction1_o9_c;



  /* DataTypeConversion: '<S642>/Data Type Conversion8' */

  L4_MABX_B.RX_status_nv = (L4_MABX_B.SFunction1_o7_l != 0.0);



  /* DataTypeConversion: '<S642>/Data Type Conversion9' */

  L4_MABX_B.RX_time_ad = L4_MABX_B.SFunction1_o8_n;



  /* DataTypeConversion: '<S644>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_at4 = L4_MABX_B.SFunction1_o7_e;



  /* DataTypeConversion: '<S644>/Data Type Conversion9' */

  L4_MABX_B.RX_time_eh = L4_MABX_B.SFunction1_o6_k;



  /* DataTypeConversion: '<S646>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_b2 = L4_MABX_B.SFunction1_o28;



  /* DataTypeConversion: '<S646>/Data Type Conversion8' */

  L4_MABX_B.RX_status_ku = (L4_MABX_B.SFunction1_o26 != 0.0);



  /* DataTypeConversion: '<S646>/Data Type Conversion9' */

  L4_MABX_B.RX_time_jq = L4_MABX_B.SFunction1_o27;



  /* DataTypeConversion: '<S648>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_p = L4_MABX_B.SFunction1_o10;



  /* DataTypeConversion: '<S648>/Data Type Conversion8' */

  L4_MABX_B.RX_status_nk = (L4_MABX_B.SFunction1_o8_m != 0.0);



  /* DataTypeConversion: '<S648>/Data Type Conversion9' */

  L4_MABX_B.RX_time_gg = L4_MABX_B.SFunction1_o9_m;



  /* DataTypeConversion: '<S650>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_cz = L4_MABX_B.SFunction1_o9;



  /* DataTypeConversion: '<S650>/Data Type Conversion8' */

  L4_MABX_B.RX_status_e3 = (L4_MABX_B.SFunction1_o7_f != 0.0);



  /* DataTypeConversion: '<S650>/Data Type Conversion9' */

  L4_MABX_B.RX_time_er = L4_MABX_B.SFunction1_o8_p;



  /* Outputs for Enabled SubSystem: '<S652>/VEP1' incorporates:

   *  EnablePort: '<S653>/Enable'

   */

  /* Constant: '<S464>/Constant' */

  if (L4_MABX_P.Constant_Value_jn > 0.0) {

    /* S-Function (rti_commonblock): '<S653>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "VEP1" Id:419362563 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEF703].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEF703].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o6 = 1.0;

        L4_MABX_B.SFunction1_o7 = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEF703].timestamp;

        L4_MABX_B.SFunction1_o8 = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEF703].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FEF703].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "NetBatteryCurrent" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_d = -125 + ( ((real_T) CAN_Sgn.UnsignedSgn) );



            /* ...... "AltCurrent" (8|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o2_lz = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "ChargingSystemPotential" (16|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o3_j5 = 0.05 * ( ((real_T) CAN_Sgn.UnsignedSgn)

              );



            /* ...... "BatteryPotential_PowerInput1" (32|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o4_pz = 0.05 * ( ((real_T) CAN_Sgn.UnsignedSgn)

              );



            /* ...... "KeyswitchBatteryPotential" (48|16, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.SgnBytes.Byte1 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

            L4_MABX_B.SFunction1_o5 = 0.05 * ( ((real_T) CAN_Sgn.UnsignedSgn) );

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o6 = 0.0;

      }

    }

  }



  /* End of Constant: '<S464>/Constant' */

  /* End of Outputs for SubSystem: '<S652>/VEP1' */



  /* DataTypeConversion: '<S652>/Data Type Conversion1' */

  L4_MABX_B.PitchAngleExRange_j = L4_MABX_B.SFunction1_o1_d;



  /* DataTypeConversion: '<S652>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_l = L4_MABX_B.SFunction1_o8;



  /* DataTypeConversion: '<S652>/Data Type Conversion2' */

  L4_MABX_B.AltCurrent = L4_MABX_B.SFunction1_o2_lz;



  /* DataTypeConversion: '<S652>/Data Type Conversion3' */

  L4_MABX_B.ChargingSystemPotential = L4_MABX_B.SFunction1_o3_j5;



  /* DataTypeConversion: '<S652>/Data Type Conversion4' */

  L4_MABX_B.BatteryPotential_PowerInput1 = L4_MABX_B.SFunction1_o4_pz;



  /* DataTypeConversion: '<S652>/Data Type Conversion5' */

  L4_MABX_B.KeyswitchBatteryPotential = L4_MABX_B.SFunction1_o5;



  /* DataTypeConversion: '<S652>/Data Type Conversion8' */

  L4_MABX_B.RX_status_kl = (L4_MABX_B.SFunction1_o6 != 0.0);



  /* DataTypeConversion: '<S652>/Data Type Conversion9' */

  L4_MABX_B.RX_time_pz = L4_MABX_B.SFunction1_o7;



  /* RelationalOperator: '<S655>/Relational Operator2' incorporates:

   *  Constant: '<S655>/TRUCK_166_VIN_CPV'

   */

  L4_MABX_B.RelationalOperator2[0] = (L4_MABX_P.TRUCK_166_VIN_CPV_Value[0] !=

    L4_MABX_B.DataTypeConversion_jo);

  L4_MABX_B.RelationalOperator2[1] = (L4_MABX_P.TRUCK_166_VIN_CPV_Value[1] !=

    L4_MABX_B.DataTypeConversion1_aq);

  L4_MABX_B.RelationalOperator2[2] = (L4_MABX_P.TRUCK_166_VIN_CPV_Value[2] !=

    L4_MABX_B.DataTypeConversion2_gd);

  L4_MABX_B.RelationalOperator2[3] = (L4_MABX_P.TRUCK_166_VIN_CPV_Value[3] !=

    L4_MABX_B.DataTypeConversion3_g);

  L4_MABX_B.RelationalOperator2[4] = (L4_MABX_P.TRUCK_166_VIN_CPV_Value[4] !=

    L4_MABX_B.DataTypeConversion4_g4);

  L4_MABX_B.RelationalOperator2[5] = (L4_MABX_P.TRUCK_166_VIN_CPV_Value[5] !=

    L4_MABX_B.DataTypeConversion5_gv);

  L4_MABX_B.RelationalOperator2[6] = (L4_MABX_P.TRUCK_166_VIN_CPV_Value[6] !=

    L4_MABX_B.DataTypeConversion6_e);

  L4_MABX_B.RelationalOperator2[7] = (L4_MABX_P.TRUCK_166_VIN_CPV_Value[7] !=

    L4_MABX_B.DataTypeConversion7_m);

  L4_MABX_B.RelationalOperator2[8] = (L4_MABX_P.TRUCK_166_VIN_CPV_Value[8] !=

    L4_MABX_B.DataTypeConversion8_aj);

  L4_MABX_B.RelationalOperator2[9] = (L4_MABX_P.TRUCK_166_VIN_CPV_Value[9] !=

    L4_MABX_B.DataTypeConversion9_o);

  L4_MABX_B.RelationalOperator2[10] = (L4_MABX_P.TRUCK_166_VIN_CPV_Value[10] !=

    L4_MABX_B.DataTypeConversion10_f5);

  L4_MABX_B.RelationalOperator2[11] = (L4_MABX_P.TRUCK_166_VIN_CPV_Value[11] !=

    L4_MABX_B.DataTypeConversion11_a);

  L4_MABX_B.RelationalOperator2[12] = (L4_MABX_P.TRUCK_166_VIN_CPV_Value[12] !=

    L4_MABX_B.DataTypeConversion12);

  L4_MABX_B.RelationalOperator2[13] = (L4_MABX_P.TRUCK_166_VIN_CPV_Value[13] !=

    L4_MABX_B.DataTypeConversion14_k);

  L4_MABX_B.RelationalOperator2[14] = (L4_MABX_P.TRUCK_166_VIN_CPV_Value[14] !=

    L4_MABX_B.DataTypeConversion13_h);

  L4_MABX_B.RelationalOperator2[15] = (L4_MABX_P.TRUCK_166_VIN_CPV_Value[15] !=

    L4_MABX_B.DataTypeConversion15_o);

  L4_MABX_B.RelationalOperator2[16] = (L4_MABX_P.TRUCK_166_VIN_CPV_Value[16] !=

    L4_MABX_B.DataTypeConversion16_o);



  /* Sum: '<S655>/Add1' */

  tmp = 0U;

  for (i = 0; i < 17; i++) {

    tmp += L4_MABX_B.RelationalOperator2[i];

  }



  L4_MABX_B.Add1_gi = (uint8_T)tmp;



  /* End of Sum: '<S655>/Add1' */



  /* RelationalOperator: '<S660>/Compare' incorporates:

   *  Constant: '<S660>/Constant'

   */

  L4_MABX_B.Compare_ho = (L4_MABX_B.Add1_gi == L4_MABX_P.Constant_Value_ln);



  /* UnitDelay: '<S655>/Unit_Delay2' */

  L4_MABX_B.Unit_Delay2_aa = L4_MABX_DW.Unit_Delay2_DSTATE_p1;



  /* Logic: '<S655>/Logical Operator1' */

  L4_MABX_B.LogicalOperator1_k = (L4_MABX_B.Unit_Delay2_aa &&

    L4_MABX_B.Compare_ho);



  /* Logic: '<S661>/Logical Operator2' */

  L4_MABX_B.LogicalOperator2_j = !L4_MABX_B.LogicalOperator1_c;



  /* UnitDelay: '<S655>/Unit_Delay1' */

  L4_MABX_B.Unit_Delay1_p = L4_MABX_DW.Unit_Delay1_DSTATE_d;



  /* Logic: '<S662>/Logical Operator3' */

  L4_MABX_B.LogicalOperator3_j = !L4_MABX_B.Unit_Delay1_p;



  /* UnitDelay: '<S662>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_nw = L4_MABX_DW.Unit_Delay_DSTATE_iv;



  /* Logic: '<S662>/Logical Operator' */

  L4_MABX_B.LogicalOperator_id = (L4_MABX_B.LogicalOperator3_j &&

    L4_MABX_B.Unit_Delay_nw);



  /* Logic: '<S662>/Logical Operator1' */

  L4_MABX_B.LogicalOperator1_cl = (L4_MABX_B.LogicalOperator1_k ||

    L4_MABX_B.LogicalOperator_id);



  /* Logic: '<S662>/Logical Operator2' */

  L4_MABX_B.LogicalOperator2_a = !L4_MABX_B.LogicalOperator1_cl;



  /* Constant: '<S421>/Constant2' */

  L4_MABX_B.PX2_HeartBeat = L4_MABX_P.Constant2_Value_i1;



  /* RelationalOperator: '<S699>/Operator' incorporates:

   *  Constant: '<S475>/Constant1'

   */

  L4_MABX_B.Operator_fb = (L4_MABX_B.DataTypeConversion_j2[0] ==

    L4_MABX_P.Constant1_Value_dt);



  /* Outputs for Enabled SubSystem: '<S475>/Decode_TPCM_CTS' incorporates:

   *  EnablePort: '<S694>/Enable'

   */

  if (L4_MABX_B.Operator_fb) {

    /* SignalConversion: '<S711>/Signal Conversion' */

    L4_MABX_B.SPN2556_ControlByte_k = L4_MABX_B.DataTypeConversion_j2[0];



    /* SignalConversion: '<S712>/Signal Conversion' */

    L4_MABX_B.SPN2561_NumberOfPacketsThatCanB = L4_MABX_B.DataTypeConversion_j2

      [1];



    /* SignalConversion: '<S713>/Signal Conversion' */

    L4_MABX_B.SPN2562_NextPacketNumberToBeSen = L4_MABX_B.DataTypeConversion_j2

      [2];



    /* DataTypeConversion: '<S714>/Data Type Conversion' */

    L4_MABX_B.DataTypeConversion_is = L4_MABX_B.DataTypeConversion_j2[5];



    /* DataTypeConversion: '<S714>/Data Type Conversion1' */

    L4_MABX_B.DataTypeConversion1_mi = L4_MABX_B.DataTypeConversion_j2[6];



    /* DataTypeConversion: '<S714>/Data Type Conversion2' */

    L4_MABX_B.DataTypeConversion2_pj = L4_MABX_B.DataTypeConversion_j2[7];



    /* ArithShift: '<S714>/Shift Arithmetic1' */

    L4_MABX_B.ShiftArithmetic1_l = L4_MABX_B.DataTypeConversion1_mi << 8;



    /* ArithShift: '<S714>/Shift Arithmetic2' */

    L4_MABX_B.ShiftArithmetic2_l = L4_MABX_B.DataTypeConversion2_pj << 16;



    /* S-Function (sfix_bitop): '<S715>/Operator' */

    L4_MABX_B.Operator_g = L4_MABX_B.DataTypeConversion_is |

      L4_MABX_B.ShiftArithmetic1_l | L4_MABX_B.ShiftArithmetic2_l;



    /* DataTypeConversion: '<S715>/DataType' */

    L4_MABX_B.DataType_b1 = L4_MABX_B.Operator_g;

  }



  /* End of Outputs for SubSystem: '<S475>/Decode_TPCM_CTS' */



  /* RelationalOperator: '<S702>/Operator' incorporates:

   *  Constant: '<S475>/Constant4'

   */

  L4_MABX_B.Operator_jd = (L4_MABX_B.DataTypeConversion_j2[0] ==

    L4_MABX_P.Constant4_Value_cy);



  /* Outputs for Enabled SubSystem: '<S475>/Decode_TPCM_ConnectionAbort' incorporates:

   *  EnablePort: '<S695>/Enable'

   */

  if (L4_MABX_B.Operator_jd) {

    /* SignalConversion: '<S717>/Signal Conversion' */

    L4_MABX_B.SPN2556_ControlByte_g = L4_MABX_B.DataTypeConversion_j2[0];



    /* SignalConversion: '<S718>/Signal Conversion' */

    L4_MABX_B.SPN2570_ConnectionAbortReason = L4_MABX_B.DataTypeConversion_j2[1];



    /* DataTypeConversion: '<S719>/Data Type Conversion' */

    L4_MABX_B.DataTypeConversion_bl = L4_MABX_B.DataTypeConversion_j2[5];



    /* DataTypeConversion: '<S719>/Data Type Conversion1' */

    L4_MABX_B.DataTypeConversion1_fh = L4_MABX_B.DataTypeConversion_j2[6];



    /* DataTypeConversion: '<S719>/Data Type Conversion2' */

    L4_MABX_B.DataTypeConversion2_gp = L4_MABX_B.DataTypeConversion_j2[7];



    /* ArithShift: '<S719>/Shift Arithmetic1' */

    L4_MABX_B.ShiftArithmetic1_fc = L4_MABX_B.DataTypeConversion1_fh << 8;



    /* ArithShift: '<S719>/Shift Arithmetic2' */

    L4_MABX_B.ShiftArithmetic2_m = L4_MABX_B.DataTypeConversion2_gp << 16;



    /* S-Function (sfix_bitop): '<S720>/Operator' */

    L4_MABX_B.Operator_il = L4_MABX_B.DataTypeConversion_bl |

      L4_MABX_B.ShiftArithmetic1_fc | L4_MABX_B.ShiftArithmetic2_m;



    /* DataTypeConversion: '<S720>/DataType' */

    L4_MABX_B.DataType_pd = L4_MABX_B.Operator_il;

  }



  /* End of Outputs for SubSystem: '<S475>/Decode_TPCM_ConnectionAbort' */



  /* RelationalOperator: '<S700>/Operator' incorporates:

   *  Constant: '<S475>/Constant2'

   */

  L4_MABX_B.Operator_hh = (L4_MABX_B.DataTypeConversion_j2[0] ==

    L4_MABX_P.Constant2_Value_j5);



  /* Outputs for Enabled SubSystem: '<S475>/Decode_TPCM_EndOfMessageAck' incorporates:

   *  EnablePort: '<S696>/Enable'

   */

  if (L4_MABX_B.Operator_hh) {

    /* SignalConversion: '<S722>/Signal Conversion' */

    L4_MABX_B.SPN2556_ControlByte_i = L4_MABX_B.DataTypeConversion_j2[0];



    /* DataTypeConversion: '<S723>/Data Type Conversion' */

    L4_MABX_B.DataTypeConversion_f = L4_MABX_B.DataTypeConversion_j2[1];



    /* DataTypeConversion: '<S723>/Data Type Conversion1' */

    L4_MABX_B.DataTypeConversion1_nk = L4_MABX_B.DataTypeConversion_j2[2];



    /* ArithShift: '<S723>/Shift Arithmetic2' */

    L4_MABX_B.ShiftArithmetic2_a = (uint16_T)(L4_MABX_B.DataTypeConversion1_nk <<

      8);



    /* S-Function (sfix_bitop): '<S726>/Operator' */

    L4_MABX_B.Operator_br = (uint16_T)(L4_MABX_B.DataTypeConversion_f |

      L4_MABX_B.ShiftArithmetic2_a);



    /* DataTypeConversion: '<S726>/DataType' */

    L4_MABX_B.DataType_ilc = L4_MABX_B.Operator_br;



    /* SignalConversion: '<S724>/Signal Conversion' */

    L4_MABX_B.SPN2565_TotalNumberOfPackets = L4_MABX_B.DataTypeConversion_j2[3];



    /* DataTypeConversion: '<S725>/Data Type Conversion' */

    L4_MABX_B.DataTypeConversion_kt = L4_MABX_B.DataTypeConversion_j2[5];



    /* DataTypeConversion: '<S725>/Data Type Conversion1' */

    L4_MABX_B.DataTypeConversion1_oh = L4_MABX_B.DataTypeConversion_j2[6];



    /* DataTypeConversion: '<S725>/Data Type Conversion2' */

    L4_MABX_B.DataTypeConversion2_mi = L4_MABX_B.DataTypeConversion_j2[7];



    /* ArithShift: '<S725>/Shift Arithmetic1' */

    L4_MABX_B.ShiftArithmetic1_f = L4_MABX_B.DataTypeConversion1_oh << 8;



    /* ArithShift: '<S725>/Shift Arithmetic2' */

    L4_MABX_B.ShiftArithmetic2_g = L4_MABX_B.DataTypeConversion2_mi << 16;



    /* S-Function (sfix_bitop): '<S727>/Operator' */

    L4_MABX_B.Operator_e2 = L4_MABX_B.DataTypeConversion_kt |

      L4_MABX_B.ShiftArithmetic1_f | L4_MABX_B.ShiftArithmetic2_g;



    /* DataTypeConversion: '<S727>/DataType' */

    L4_MABX_B.DataType_m2 = L4_MABX_B.Operator_e2;

  }



  /* End of Outputs for SubSystem: '<S475>/Decode_TPCM_EndOfMessageAck' */



  /* RelationalOperator: '<S698>/Operator' incorporates:

   *  Constant: '<S475>/Constant'

   */

  L4_MABX_B.Operator_eu = (L4_MABX_B.DataTypeConversion_j2[0] ==

    L4_MABX_P.Constant_Value_hv);



  /* Outputs for Enabled SubSystem: '<S475>/Decode_TPCM_RTS' incorporates:

   *  EnablePort: '<S697>/Enable'

   */

  if (L4_MABX_B.Operator_eu) {

    /* SignalConversion: '<S729>/Signal Conversion' */

    L4_MABX_B.SPN2556_ControlByte = L4_MABX_B.DataTypeConversion_j2[0];



    /* DataTypeConversion: '<S730>/Data Type Conversion' */

    L4_MABX_B.DataTypeConversion_eu = L4_MABX_B.DataTypeConversion_j2[1];



    /* DataTypeConversion: '<S730>/Data Type Conversion1' */

    L4_MABX_B.DataTypeConversion1_jf = L4_MABX_B.DataTypeConversion_j2[2];



    /* ArithShift: '<S730>/Shift Arithmetic2' */

    L4_MABX_B.ShiftArithmetic2_i = (uint16_T)(L4_MABX_B.DataTypeConversion1_jf <<

      8);



    /* S-Function (sfix_bitop): '<S734>/Operator' */

    L4_MABX_B.Operator_kf = (uint16_T)(L4_MABX_B.DataTypeConversion_eu |

      L4_MABX_B.ShiftArithmetic2_i);



    /* DataTypeConversion: '<S734>/DataType' */

    L4_MABX_B.DataType_fn = L4_MABX_B.Operator_kf;



    /* SignalConversion: '<S731>/Signal Conversion' */

    L4_MABX_B.SPN2558_TotalNumberOfPackets = L4_MABX_B.DataTypeConversion_j2[3];



    /* SignalConversion: '<S732>/Signal Conversion' */

    L4_MABX_B.SPN2559_MaximumNumberOfPackets = L4_MABX_B.DataTypeConversion_j2[4];



    /* DataTypeConversion: '<S733>/Data Type Conversion' */

    L4_MABX_B.DataTypeConversion_p4 = L4_MABX_B.DataTypeConversion_j2[5];



    /* DataTypeConversion: '<S733>/Data Type Conversion1' */

    L4_MABX_B.DataTypeConversion1_c = L4_MABX_B.DataTypeConversion_j2[6];



    /* DataTypeConversion: '<S733>/Data Type Conversion2' */

    L4_MABX_B.DataTypeConversion2_h1 = L4_MABX_B.DataTypeConversion_j2[7];



    /* ArithShift: '<S733>/Shift Arithmetic1' */

    L4_MABX_B.ShiftArithmetic1 = L4_MABX_B.DataTypeConversion1_c << 8;



    /* ArithShift: '<S733>/Shift Arithmetic2' */

    L4_MABX_B.ShiftArithmetic2 = L4_MABX_B.DataTypeConversion2_h1 << 16;



    /* S-Function (sfix_bitop): '<S735>/Operator' */

    L4_MABX_B.Operator_nr = L4_MABX_B.DataTypeConversion_p4 |

      L4_MABX_B.ShiftArithmetic1 | L4_MABX_B.ShiftArithmetic2;



    /* DataTypeConversion: '<S735>/DataType' */

    L4_MABX_B.DataType_ke = L4_MABX_B.Operator_nr;

  }



  /* End of Outputs for SubSystem: '<S475>/Decode_TPCM_RTS' */



  /* RelationalOperator: '<S595>/Operator' incorporates:

   *  Constant: '<S450>/Constant'

   *  Constant: '<S591>/Constant'

   */

  L4_MABX_B.Operator_kmo = (PROPB_REAX_CHANNEL_APV ==

    L4_MABX_P.Constant_Value_b4);



  /* Outputs for Enabled SubSystem: '<S588>/CAN_TYPE1_RX_M1_C1' incorporates:

   *  EnablePort: '<S592>/Enable'

   */

  if (L4_MABX_B.Operator_kmo) {

    /* S-Function (rti_commonblock): '<S592>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "PropB_REAX_3_13" Id:419426579 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FFF113].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FFF113].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o9_i4 = 1.0;

        L4_MABX_B.SFunction1_o10_hc = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FFF113].timestamp;

        L4_MABX_B.SFunction1_o11_n = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FFF113].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FFF113].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "byte1" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_f0 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte2" (8|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o2_pl = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte3" (16|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o3_pe = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte4" (24|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o4_h2 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte5" (32|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o5_m0 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte6" (40|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o6_b1 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte7" (48|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o7_al = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte8" (56|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o8_ar = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o9_i4 = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S588>/CAN_TYPE1_RX_M1_C1' */



  /* RelationalOperator: '<S596>/Operator' incorporates:

   *  Constant: '<S450>/Constant'

   *  Constant: '<S591>/Constant1'

   */

  L4_MABX_B.Operator_ef = (PROPB_REAX_CHANNEL_APV ==

    L4_MABX_P.Constant1_Value_a3);



  /* Outputs for Enabled SubSystem: '<S589>/CAN_TYPE1_RX_M1_C2' incorporates:

   *  EnablePort: '<S593>/Enable'

   */

  if (L4_MABX_B.Operator_ef) {

    /* S-Function (rti_commonblock): '<S593>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "PropB_REAX_3_13" Id:419426579 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FFF113].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FFF113].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o9_jm = 1.0;

        L4_MABX_B.SFunction1_o10_o = (real_T)

          can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FFF113].timestamp;

        L4_MABX_B.SFunction1_o11_fl = (real_T)

          can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FFF113].deltatime;

        CAN_Msg = can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FFF113].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "byte1" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_np = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte2" (8|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o2_bp = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte3" (16|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o3_cq = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte4" (24|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o4_ph = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte5" (32|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o5_iy = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte6" (40|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o6_g4 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte7" (48|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o7_ea = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte8" (56|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o8_c = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o9_jm = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S589>/CAN_TYPE1_RX_M1_C2' */



  /* DataTypeConversion: '<S589>/Data Type Conversion' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o1_np;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion_h1 = starting_index;



  /* End of DataTypeConversion: '<S589>/Data Type Conversion' */



  /* DataTypeConversion: '<S589>/Data Type Conversion1' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o2_bp;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion1_lj = starting_index;



  /* End of DataTypeConversion: '<S589>/Data Type Conversion1' */



  /* DataTypeConversion: '<S589>/Data Type Conversion2' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o3_cq;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion2_j = starting_index;



  /* End of DataTypeConversion: '<S589>/Data Type Conversion2' */



  /* DataTypeConversion: '<S589>/Data Type Conversion3' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o4_ph;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion3_gc = starting_index;



  /* End of DataTypeConversion: '<S589>/Data Type Conversion3' */



  /* DataTypeConversion: '<S589>/Data Type Conversion4' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o5_iy;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion4_ec = starting_index;



  /* End of DataTypeConversion: '<S589>/Data Type Conversion4' */



  /* DataTypeConversion: '<S589>/Data Type Conversion5' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o6_g4;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion5_b = starting_index;



  /* End of DataTypeConversion: '<S589>/Data Type Conversion5' */



  /* DataTypeConversion: '<S589>/Data Type Conversion6' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o7_ea;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion6_g = starting_index;



  /* End of DataTypeConversion: '<S589>/Data Type Conversion6' */



  /* DataTypeConversion: '<S589>/Data Type Conversion7' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o8_c;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion7_ic = starting_index;



  /* End of DataTypeConversion: '<S589>/Data Type Conversion7' */



  /* RelationalOperator: '<S600>/Operator' incorporates:

   *  Constant: '<S450>/Constant'

   *  Constant: '<S591>/Constant5'

   */

  L4_MABX_B.Operator_fhg = (PROPB_REAX_CHANNEL_APV ==

    L4_MABX_P.Constant5_Value_n);



  /* Outputs for Enabled SubSystem: '<S590>/CAN_TYPE1_RX_M3_C2' incorporates:

   *  EnablePort: '<S594>/Enable'

   */

  if (L4_MABX_B.Operator_fhg) {

    /* S-Function (rti_commonblock): '<S594>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "PropB_REAX_3_13" Id:486535443 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M3_C2_XTD[CANTP1_M3_C2_RXSRVC_XTD_0x1CFFF113].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M3_C2_XTD[CANTP1_M3_C2_RXSRVC_XTD_0x1CFFF113].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o9_kq = 1.0;

        L4_MABX_B.SFunction1_o10_f = (real_T)

          can_type1_M3_C2_XTD[CANTP1_M3_C2_RXSRVC_XTD_0x1CFFF113].timestamp;

        L4_MABX_B.SFunction1_o11_o = (real_T)

          can_type1_M3_C2_XTD[CANTP1_M3_C2_RXSRVC_XTD_0x1CFFF113].deltatime;

        CAN_Msg = can_type1_M3_C2_XTD[CANTP1_M3_C2_RXSRVC_XTD_0x1CFFF113].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "byte1" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_ae = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte2" (8|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o2_nt = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte3" (16|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o3_ng = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte4" (24|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o4_okw = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte5" (32|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o5_l = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte6" (40|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o6_nq = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte7" (48|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o7_lb = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte8" (56|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o8_bi = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o9_kq = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S590>/CAN_TYPE1_RX_M3_C2' */



  /* DataTypeConversion: '<S590>/Data Type Conversion' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o1_ae;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion_ld = starting_index;



  /* End of DataTypeConversion: '<S590>/Data Type Conversion' */



  /* DataTypeConversion: '<S590>/Data Type Conversion1' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o2_nt;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion1_j1 = starting_index;



  /* End of DataTypeConversion: '<S590>/Data Type Conversion1' */



  /* DataTypeConversion: '<S590>/Data Type Conversion2' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o3_ng;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion2_el = starting_index;



  /* End of DataTypeConversion: '<S590>/Data Type Conversion2' */



  /* DataTypeConversion: '<S590>/Data Type Conversion3' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o4_okw;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion3_em = starting_index;



  /* End of DataTypeConversion: '<S590>/Data Type Conversion3' */



  /* DataTypeConversion: '<S590>/Data Type Conversion4' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o5_l;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion4_iu = starting_index;



  /* End of DataTypeConversion: '<S590>/Data Type Conversion4' */



  /* DataTypeConversion: '<S590>/Data Type Conversion5' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o6_nq;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion5_hq = starting_index;



  /* End of DataTypeConversion: '<S590>/Data Type Conversion5' */



  /* DataTypeConversion: '<S590>/Data Type Conversion6' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o7_lb;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion6_d = starting_index;



  /* End of DataTypeConversion: '<S590>/Data Type Conversion6' */



  /* DataTypeConversion: '<S590>/Data Type Conversion7' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o8_bi;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion7_ed = starting_index;



  /* End of DataTypeConversion: '<S590>/Data Type Conversion7' */



  /* MultiPortSwitch: '<S450>/Multiport_Switch' incorporates:

   *  Constant: '<S450>/Constant'

   */

  switch (PROPB_REAX_CHANNEL_APV) {

   case ENUM_CAN_RX_T_RX_CAN_1:

    /* DataTypeConversion: '<S588>/Data Type Conversion' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o1_f0;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion_kt2 = starting_index;



    /* End of DataTypeConversion: '<S588>/Data Type Conversion' */



    /* DataTypeConversion: '<S588>/Data Type Conversion1' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o2_pl;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion1_kf = starting_index;



    /* End of DataTypeConversion: '<S588>/Data Type Conversion1' */



    /* DataTypeConversion: '<S588>/Data Type Conversion2' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o3_pe;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion2_mr = starting_index;



    /* End of DataTypeConversion: '<S588>/Data Type Conversion2' */



    /* DataTypeConversion: '<S588>/Data Type Conversion3' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o4_h2;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion3_lq = starting_index;



    /* End of DataTypeConversion: '<S588>/Data Type Conversion3' */



    /* DataTypeConversion: '<S588>/Data Type Conversion4' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o5_m0;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion4_le = starting_index;



    /* End of DataTypeConversion: '<S588>/Data Type Conversion4' */



    /* DataTypeConversion: '<S588>/Data Type Conversion5' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o6_b1;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion5_dk = starting_index;



    /* End of DataTypeConversion: '<S588>/Data Type Conversion5' */



    /* DataTypeConversion: '<S588>/Data Type Conversion6' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o7_al;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion6_fl = starting_index;



    /* End of DataTypeConversion: '<S588>/Data Type Conversion6' */



    /* DataTypeConversion: '<S588>/Data Type Conversion7' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o8_ar;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion7_ix = starting_index;



    /* End of DataTypeConversion: '<S588>/Data Type Conversion7' */

    L4_MABX_B.RawData_p[0] = L4_MABX_B.DataTypeConversion_kt2;

    L4_MABX_B.RawData_p[1] = L4_MABX_B.DataTypeConversion1_kf;

    L4_MABX_B.RawData_p[2] = L4_MABX_B.DataTypeConversion2_mr;

    L4_MABX_B.RawData_p[3] = L4_MABX_B.DataTypeConversion3_lq;

    L4_MABX_B.RawData_p[4] = L4_MABX_B.DataTypeConversion4_le;

    L4_MABX_B.RawData_p[5] = L4_MABX_B.DataTypeConversion5_dk;

    L4_MABX_B.RawData_p[6] = L4_MABX_B.DataTypeConversion6_fl;

    L4_MABX_B.RawData_p[7] = L4_MABX_B.DataTypeConversion7_ix;

    break;



   case ENUM_CAN_RX_T_RX_CAN_2:

    L4_MABX_B.RawData_p[0] = L4_MABX_B.DataTypeConversion_h1;

    L4_MABX_B.RawData_p[1] = L4_MABX_B.DataTypeConversion1_lj;

    L4_MABX_B.RawData_p[2] = L4_MABX_B.DataTypeConversion2_j;

    L4_MABX_B.RawData_p[3] = L4_MABX_B.DataTypeConversion3_gc;

    L4_MABX_B.RawData_p[4] = L4_MABX_B.DataTypeConversion4_ec;

    L4_MABX_B.RawData_p[5] = L4_MABX_B.DataTypeConversion5_b;

    L4_MABX_B.RawData_p[6] = L4_MABX_B.DataTypeConversion6_g;

    L4_MABX_B.RawData_p[7] = L4_MABX_B.DataTypeConversion7_ic;

    break;



   case ENUM_CAN_RX_T_RX_CAN_3:

    L4_MABX_B.RawData_p[0] = L4_MABX_B.DataTypeConversion_h1;

    L4_MABX_B.RawData_p[1] = L4_MABX_B.DataTypeConversion1_lj;

    L4_MABX_B.RawData_p[2] = L4_MABX_B.DataTypeConversion2_j;

    L4_MABX_B.RawData_p[3] = L4_MABX_B.DataTypeConversion3_gc;

    L4_MABX_B.RawData_p[4] = L4_MABX_B.DataTypeConversion4_ec;

    L4_MABX_B.RawData_p[5] = L4_MABX_B.DataTypeConversion5_b;

    L4_MABX_B.RawData_p[6] = L4_MABX_B.DataTypeConversion6_g;

    L4_MABX_B.RawData_p[7] = L4_MABX_B.DataTypeConversion7_ic;

    break;



   case ENUM_CAN_RX_T_RX_CAN_4:

    L4_MABX_B.RawData_p[0] = L4_MABX_B.DataTypeConversion_h1;

    L4_MABX_B.RawData_p[1] = L4_MABX_B.DataTypeConversion1_lj;

    L4_MABX_B.RawData_p[2] = L4_MABX_B.DataTypeConversion2_j;

    L4_MABX_B.RawData_p[3] = L4_MABX_B.DataTypeConversion3_gc;

    L4_MABX_B.RawData_p[4] = L4_MABX_B.DataTypeConversion4_ec;

    L4_MABX_B.RawData_p[5] = L4_MABX_B.DataTypeConversion5_b;

    L4_MABX_B.RawData_p[6] = L4_MABX_B.DataTypeConversion6_g;

    L4_MABX_B.RawData_p[7] = L4_MABX_B.DataTypeConversion7_ic;

    break;



   case ENUM_CAN_RX_T_RX_CAN_5:

    L4_MABX_B.RawData_p[0] = L4_MABX_B.DataTypeConversion_h1;

    L4_MABX_B.RawData_p[1] = L4_MABX_B.DataTypeConversion1_lj;

    L4_MABX_B.RawData_p[2] = L4_MABX_B.DataTypeConversion2_j;

    L4_MABX_B.RawData_p[3] = L4_MABX_B.DataTypeConversion3_gc;

    L4_MABX_B.RawData_p[4] = L4_MABX_B.DataTypeConversion4_ec;

    L4_MABX_B.RawData_p[5] = L4_MABX_B.DataTypeConversion5_b;

    L4_MABX_B.RawData_p[6] = L4_MABX_B.DataTypeConversion6_g;

    L4_MABX_B.RawData_p[7] = L4_MABX_B.DataTypeConversion7_ic;

    break;



   case ENUM_CAN_RX_T_RX_CAN_6:

    L4_MABX_B.RawData_p[0] = L4_MABX_B.DataTypeConversion_ld;

    L4_MABX_B.RawData_p[1] = L4_MABX_B.DataTypeConversion1_j1;

    L4_MABX_B.RawData_p[2] = L4_MABX_B.DataTypeConversion2_el;

    L4_MABX_B.RawData_p[3] = L4_MABX_B.DataTypeConversion3_em;

    L4_MABX_B.RawData_p[4] = L4_MABX_B.DataTypeConversion4_iu;

    L4_MABX_B.RawData_p[5] = L4_MABX_B.DataTypeConversion5_hq;

    L4_MABX_B.RawData_p[6] = L4_MABX_B.DataTypeConversion6_d;

    L4_MABX_B.RawData_p[7] = L4_MABX_B.DataTypeConversion7_ed;

    break;



   default:

    L4_MABX_B.RawData_p[0] = L4_MABX_B.DataTypeConversion_ld;

    L4_MABX_B.RawData_p[1] = L4_MABX_B.DataTypeConversion1_j1;

    L4_MABX_B.RawData_p[2] = L4_MABX_B.DataTypeConversion2_el;

    L4_MABX_B.RawData_p[3] = L4_MABX_B.DataTypeConversion3_em;

    L4_MABX_B.RawData_p[4] = L4_MABX_B.DataTypeConversion4_iu;

    L4_MABX_B.RawData_p[5] = L4_MABX_B.DataTypeConversion5_hq;

    L4_MABX_B.RawData_p[6] = L4_MABX_B.DataTypeConversion6_d;

    L4_MABX_B.RawData_p[7] = L4_MABX_B.DataTypeConversion7_ed;

    break;

  }



  /* S-Function (sfix_bitop): '<S678>/Operator' */

  L4_MABX_B.Operator_ea = (uint8_T)(L4_MABX_B.RawData_p[0] &

    L4_MABX_P.Operator_BitMask_lh);



  /* DataTypeConversion: '<S678>/DataType' */

  L4_MABX_B.DataType_bm = L4_MABX_B.Operator_ea;



  /* DataTypeConversion: '<S425>/Data Type Conversion' */

  REAX_Current_Mode = L4_MABX_B.DataType_bm;



  /* S-Function (sfix_bitop): '<S677>/Operator' */

  L4_MABX_B.Operator_nj = (uint8_T)(L4_MABX_B.RawData_p[0] &

    L4_MABX_P.Operator_BitMask_py);



  /* DataTypeConversion: '<S677>/DataType' */

  L4_MABX_B.DataType_bg = L4_MABX_B.Operator_nj;



  /* ArithShift: '<S672>/Shift_Arithmetic ' */

  L4_MABX_B.PropB_REAX_3_ReqOperatingMode = (uint8_T)((uint32_T)

    L4_MABX_B.DataType_bg >> 4);



  /* DataTypeConversion: '<S425>/Data Type Conversion1' */

  REAX_Req_Mode = L4_MABX_B.PropB_REAX_3_ReqOperatingMode;



  /* DataTypeConversion: '<S425>/Data Type Conversion2' */

  REAX_Status = L4_MABX_B.RawData_p[1];



  /* DataTypeConversion: '<S674>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_p = L4_MABX_B.RawData_p[2];



  /* DataTypeConversion: '<S674>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_a2 = L4_MABX_B.RawData_p[3];



  /* ArithShift: '<S674>/Shift_Arithmetic 1' */

  L4_MABX_B.Shift_Arithmetic1_nf = (uint16_T)(L4_MABX_B.DataTypeConversion2_a2 <<

    8);



  /* S-Function (sfix_bitop): '<S679>/Operator' */

  L4_MABX_B.Operator_ay = (uint16_T)(L4_MABX_B.DataTypeConversion1_p |

    L4_MABX_B.Shift_Arithmetic1_nf);



  /* DataTypeConversion: '<S679>/DataType' */

  L4_MABX_B.DataType_jt = L4_MABX_B.Operator_ay;



  /* DataTypeConversion: '<S674>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_im = (int16_T)L4_MABX_B.DataType_jt;



  /* DataTypeConversion: '<S674>/Data Type Conversion4' */

  L4_MABX_B.DataTypeConversion4_a = L4_MABX_B.DataTypeConversion3_im;



  /* Product: '<S674>/Product' incorporates:

   *  Constant: '<S674>/Constant'

   */

  L4_MABX_B.PropB_REAX_3_HandwheelTorque = (real32_T)

    (L4_MABX_B.DataTypeConversion4_a * L4_MABX_P.Constant_Value_f5);



  /* DataTypeConversion: '<S425>/Data Type Conversion3' */

  REAX_Handwheel_Torque = L4_MABX_B.PropB_REAX_3_HandwheelTorque;



  /* DataTypeConversion: '<S675>/Data Type Conversion4' */

  L4_MABX_B.DataTypeConversion4_i5 = L4_MABX_B.RawData_p[4];



  /* DataTypeConversion: '<S675>/Data Type Conversion5' */

  L4_MABX_B.DataTypeConversion5_d3 = L4_MABX_B.RawData_p[5];



  /* ArithShift: '<S675>/Shift_Arithmetic 2' */

  L4_MABX_B.Shift_Arithmetic2_c = (uint16_T)(L4_MABX_B.DataTypeConversion5_d3 <<

    8);



  /* S-Function (sfix_bitop): '<S680>/Operator' */

  L4_MABX_B.Operator_iu = (uint16_T)(L4_MABX_B.DataTypeConversion4_i5 |

    L4_MABX_B.Shift_Arithmetic2_c);



  /* DataTypeConversion: '<S680>/DataType' */

  L4_MABX_B.DataType_bv = L4_MABX_B.Operator_iu;



  /* DataTypeConversion: '<S675>/Data Type Conversion6' */

  L4_MABX_B.DataTypeConversion6_j = (int16_T)L4_MABX_B.DataType_bv;



  /* DataTypeConversion: '<S675>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_m = L4_MABX_B.DataTypeConversion6_j;



  /* Product: '<S675>/Product1' incorporates:

   *  Constant: '<S675>/Constant1'

   */

  L4_MABX_B.PropB_REAX_3_HandwheelVelocity = (real32_T)

    (L4_MABX_B.DataTypeConversion1_m * L4_MABX_P.Constant1_Value_fw);



  /* DataTypeConversion: '<S425>/Data Type Conversion4' */

  REAX_Handwheel_Velocity = L4_MABX_B.PropB_REAX_3_HandwheelVelocity;



  /* DataTypeConversion: '<S676>/Data Type Conversion7' */

  L4_MABX_B.DataTypeConversion7_g = L4_MABX_B.RawData_p[6];



  /* DataTypeConversion: '<S676>/Data Type Conversion8' */

  L4_MABX_B.DataTypeConversion8_f = L4_MABX_B.RawData_p[7];



  /* ArithShift: '<S676>/Shift_Arithmetic 3' */

  L4_MABX_B.Shift_Arithmetic3_fa = (uint16_T)(L4_MABX_B.DataTypeConversion8_f <<

    8);



  /* S-Function (sfix_bitop): '<S681>/Operator' */

  L4_MABX_B.Operator_ae = (uint16_T)(L4_MABX_B.DataTypeConversion7_g |

    L4_MABX_B.Shift_Arithmetic3_fa);



  /* DataTypeConversion: '<S681>/DataType' */

  L4_MABX_B.DataType_pp = L4_MABX_B.Operator_ae;



  /* DataTypeConversion: '<S676>/Data Type Conversion9' */

  L4_MABX_B.DataTypeConversion9_i = (int16_T)L4_MABX_B.DataType_pp;



  /* DataTypeConversion: '<S676>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_e = L4_MABX_B.DataTypeConversion9_i;



  /* Product: '<S676>/Product2' incorporates:

   *  Constant: '<S676>/Constant2'

   */

  L4_MABX_B.PropB_REAX_3_PullCompensation = (real32_T)

    (L4_MABX_B.DataTypeConversion1_e * L4_MABX_P.Constant2_Value_hh);



  /* DataTypeConversion: '<S425>/Data Type Conversion5' */

  REAX_Pull_Compensation = L4_MABX_B.PropB_REAX_3_PullCompensation;



  /* DataTypeConversion: '<S589>/Data Type Conversion8' */

  L4_MABX_B.RX_status_i = (L4_MABX_B.SFunction1_o9_jm != 0.0);



  /* DataTypeConversion: '<S590>/Data Type Conversion8' */

  L4_MABX_B.RX_status_bv = (L4_MABX_B.SFunction1_o9_kq != 0.0);



  /* MultiPortSwitch: '<S450>/Multiport_Switch' incorporates:

   *  Constant: '<S450>/Constant'

   */

  switch (PROPB_REAX_CHANNEL_APV) {

   case ENUM_CAN_RX_T_RX_CAN_1:

    /* DataTypeConversion: '<S588>/Data Type Conversion8' */

    L4_MABX_B.RX_status_md = (L4_MABX_B.SFunction1_o9_i4 != 0.0);

    L4_MABX_B.RX_status_nd = L4_MABX_B.RX_status_md;

    break;



   case ENUM_CAN_RX_T_RX_CAN_2:

    L4_MABX_B.RX_status_nd = L4_MABX_B.RX_status_i;

    break;



   case ENUM_CAN_RX_T_RX_CAN_3:

    L4_MABX_B.RX_status_nd = L4_MABX_B.RX_status_i;

    break;



   case ENUM_CAN_RX_T_RX_CAN_4:

    L4_MABX_B.RX_status_nd = L4_MABX_B.RX_status_i;

    break;



   case ENUM_CAN_RX_T_RX_CAN_5:

    L4_MABX_B.RX_status_nd = L4_MABX_B.RX_status_i;

    break;



   case ENUM_CAN_RX_T_RX_CAN_6:

    L4_MABX_B.RX_status_nd = L4_MABX_B.RX_status_bv;

    break;



   default:

    L4_MABX_B.RX_status_nd = L4_MABX_B.RX_status_bv;

    break;

  }



  /* DataTypeConversion: '<S589>/Data Type Conversion9' */

  L4_MABX_B.RX_time_dq = L4_MABX_B.SFunction1_o10_o;



  /* DataTypeConversion: '<S590>/Data Type Conversion9' */

  L4_MABX_B.RX_time_it = L4_MABX_B.SFunction1_o10_f;



  /* MultiPortSwitch: '<S450>/Multiport_Switch' incorporates:

   *  Constant: '<S450>/Constant'

   */

  switch (PROPB_REAX_CHANNEL_APV) {

   case ENUM_CAN_RX_T_RX_CAN_1:

    /* DataTypeConversion: '<S588>/Data Type Conversion9' */

    L4_MABX_B.RX_time_cx = L4_MABX_B.SFunction1_o10_hc;

    L4_MABX_B.RX_time_k3 = L4_MABX_B.RX_time_cx;

    break;



   case ENUM_CAN_RX_T_RX_CAN_2:

    L4_MABX_B.RX_time_k3 = L4_MABX_B.RX_time_dq;

    break;



   case ENUM_CAN_RX_T_RX_CAN_3:

    L4_MABX_B.RX_time_k3 = L4_MABX_B.RX_time_dq;

    break;



   case ENUM_CAN_RX_T_RX_CAN_4:

    L4_MABX_B.RX_time_k3 = L4_MABX_B.RX_time_dq;

    break;



   case ENUM_CAN_RX_T_RX_CAN_5:

    L4_MABX_B.RX_time_k3 = L4_MABX_B.RX_time_dq;

    break;



   case ENUM_CAN_RX_T_RX_CAN_6:

    L4_MABX_B.RX_time_k3 = L4_MABX_B.RX_time_it;

    break;



   default:

    L4_MABX_B.RX_time_k3 = L4_MABX_B.RX_time_it;

    break;

  }



  /* DataTypeConversion: '<S589>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_bc = L4_MABX_B.SFunction1_o11_fl;



  /* DataTypeConversion: '<S590>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_in = L4_MABX_B.SFunction1_o11_o;



  /* MultiPortSwitch: '<S450>/Multiport_Switch' incorporates:

   *  Constant: '<S450>/Constant'

   */

  switch (PROPB_REAX_CHANNEL_APV) {

   case ENUM_CAN_RX_T_RX_CAN_1:

    /* DataTypeConversion: '<S588>/Data Type Conversion10' */

    L4_MABX_B.RX_delta_time_pa = L4_MABX_B.SFunction1_o11_n;

    L4_MABX_B.RX_delta_time_ip = L4_MABX_B.RX_delta_time_pa;

    break;



   case ENUM_CAN_RX_T_RX_CAN_2:

    L4_MABX_B.RX_delta_time_ip = L4_MABX_B.RX_delta_time_bc;

    break;



   case ENUM_CAN_RX_T_RX_CAN_3:

    L4_MABX_B.RX_delta_time_ip = L4_MABX_B.RX_delta_time_bc;

    break;



   case ENUM_CAN_RX_T_RX_CAN_4:

    L4_MABX_B.RX_delta_time_ip = L4_MABX_B.RX_delta_time_bc;

    break;



   case ENUM_CAN_RX_T_RX_CAN_5:

    L4_MABX_B.RX_delta_time_ip = L4_MABX_B.RX_delta_time_bc;

    break;



   case ENUM_CAN_RX_T_RX_CAN_6:

    L4_MABX_B.RX_delta_time_ip = L4_MABX_B.RX_delta_time_in;

    break;



   default:

    L4_MABX_B.RX_delta_time_ip = L4_MABX_B.RX_delta_time_in;

    break;

  }



  /* RelationalOperator: '<S597>/Operator' incorporates:

   *  Constant: '<S450>/Constant'

   *  Constant: '<S591>/Constant2'

   */

  L4_MABX_B.Operator_pzw = (PROPB_REAX_CHANNEL_APV ==

    L4_MABX_P.Constant2_Value_o);



  /* RelationalOperator: '<S598>/Operator' incorporates:

   *  Constant: '<S450>/Constant'

   *  Constant: '<S591>/Constant3'

   */

  L4_MABX_B.Operator_pt = (PROPB_REAX_CHANNEL_APV ==

    L4_MABX_P.Constant3_Value_lx);



  /* RelationalOperator: '<S599>/Operator' incorporates:

   *  Constant: '<S450>/Constant'

   *  Constant: '<S591>/Constant4'

   */

  L4_MABX_B.Operator_fo = (PROPB_REAX_CHANNEL_APV == L4_MABX_P.Constant4_Value_c);



  /* RelationalOperator: '<S608>/Operator' incorporates:

   *  Constant: '<S451>/Constant'

   *  Constant: '<S604>/Constant'

   */

  L4_MABX_B.Operator_c2 = (PROPB_REAX_CHANNEL_APV == L4_MABX_P.Constant_Value_er);



  /* Outputs for Enabled SubSystem: '<S601>/CAN_TYPE1_RX_M1_C1' incorporates:

   *  EnablePort: '<S605>/Enable'

   */

  if (L4_MABX_B.Operator_c2) {

    /* S-Function (rti_commonblock): '<S605>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "PropB_REAX_4_13" Id:419428115 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FFF713].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FFF713].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o9_e = 1.0;

        L4_MABX_B.SFunction1_o10_a = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FFF713].timestamp;

        L4_MABX_B.SFunction1_o11_f = (real_T)

          can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FFF713].deltatime;

        CAN_Msg = can_type1_M1_C1_XTD[CANTP1_M1_C1_RXSRVC_XTD_0x18FFF713].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "byte1" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_nw = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte2" (8|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o2_bx = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte3" (16|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o3_hu = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte4" (24|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o4_i2 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte5" (32|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o5_mc = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte6" (40|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o6_bm = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte7" (48|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o7_p0 = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte8" (56|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o8_j = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o9_e = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S601>/CAN_TYPE1_RX_M1_C1' */



  /* RelationalOperator: '<S609>/Operator' incorporates:

   *  Constant: '<S451>/Constant'

   *  Constant: '<S604>/Constant1'

   */

  L4_MABX_B.Operator_ad = (PROPB_REAX_CHANNEL_APV ==

    L4_MABX_P.Constant1_Value_bi);



  /* Outputs for Enabled SubSystem: '<S602>/CAN_TYPE1_RX_M1_C2' incorporates:

   *  EnablePort: '<S606>/Enable'

   */

  if (L4_MABX_B.Operator_ad) {

    /* S-Function (rti_commonblock): '<S606>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "PropB_REAX_4_13" Id:419428115 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FFF713].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FFF713].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o9_o = 1.0;

        L4_MABX_B.SFunction1_o10_p = (real_T)

          can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FFF713].timestamp;

        L4_MABX_B.SFunction1_o11_g = (real_T)

          can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FFF713].deltatime;

        CAN_Msg = can_type1_M1_C2_XTD[CANTP1_M1_C2_RXSRVC_XTD_0x18FFF713].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "byte1" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_dc = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte2" (8|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o2_bu = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte3" (16|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o3_mi = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte4" (24|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o4_hm = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte5" (32|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o5_bl = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte6" (40|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o6_e = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte7" (48|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o7_cl = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte8" (56|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o8_d = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o9_o = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S602>/CAN_TYPE1_RX_M1_C2' */



  /* RelationalOperator: '<S613>/Operator' incorporates:

   *  Constant: '<S451>/Constant'

   *  Constant: '<S604>/Constant5'

   */

  L4_MABX_B.Operator_dp = (PROPB_REAX_CHANNEL_APV ==

    L4_MABX_P.Constant5_Value_o2);



  /* Outputs for Enabled SubSystem: '<S603>/CAN_TYPE1_RX_M3_C2' incorporates:

   *  EnablePort: '<S607>/Enable'

   */

  if (L4_MABX_B.Operator_dp) {

    /* S-Function (rti_commonblock): '<S607>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN RX Message Block: "PropB_REAX_4_13" Id:486536979 */

    {

      UInt32 *CAN_Msg;

      static dsfloat time_old = 0.0;



      /* Read status and timestamp info (previous message) */

      if (can_type1_M3_C2_XTD[CANTP1_M3_C2_RXSRVC_XTD_0x1CFFF713].timestamp !=

          time_old) {

        /* ... save timestamp info for the calculation of the RX status

           during the consecutive sample hit*/

        time_old = can_type1_M3_C2_XTD[CANTP1_M3_C2_RXSRVC_XTD_0x1CFFF713].

          timestamp;



        /* ... set the processed flag to one */

        L4_MABX_B.SFunction1_o9_h = 1.0;

        L4_MABX_B.SFunction1_o10_c = (real_T)

          can_type1_M3_C2_XTD[CANTP1_M3_C2_RXSRVC_XTD_0x1CFFF713].timestamp;

        L4_MABX_B.SFunction1_o11_a = (real_T)

          can_type1_M3_C2_XTD[CANTP1_M3_C2_RXSRVC_XTD_0x1CFFF713].deltatime;

        CAN_Msg = can_type1_M3_C2_XTD[CANTP1_M3_C2_RXSRVC_XTD_0x1CFFF713].data;



        /* Decode CAN message */

        {

          {

            rtican_Signal_t CAN_Sgn;



            /* ...... "byte1" (0|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[0];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o1_oz = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte2" (8|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[1];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o2_hr = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte3" (16|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[2];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o3_cc = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte4" (24|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[3];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o4_ok = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte5" (32|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[4];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o5_m = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte6" (40|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[5];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o6_p = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte7" (48|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[6];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o7_pe = ((real_T) CAN_Sgn.UnsignedSgn);



            /* ...... "byte8" (56|8, standard signal, unsigned int, little endian) */

            CAN_Sgn.SgnBytes.Byte0 = CAN_Msg[7];

            CAN_Sgn.UnsignedSgn &= 0x000000FF;

            L4_MABX_B.SFunction1_o8_o = ((real_T) CAN_Sgn.UnsignedSgn);

          }

        }

      } else {

        /* set RX status to 0 because no new message has arrived */

        L4_MABX_B.SFunction1_o9_h = 0.0;

      }

    }

  }



  /* End of Outputs for SubSystem: '<S603>/CAN_TYPE1_RX_M3_C2' */



  /* DataTypeConversion: '<S603>/Data Type Conversion' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o1_oz;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion_ll = starting_index;



  /* End of DataTypeConversion: '<S603>/Data Type Conversion' */



  /* DataTypeConversion: '<S603>/Data Type Conversion1' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o2_hr;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion1_ow = starting_index;



  /* End of DataTypeConversion: '<S603>/Data Type Conversion1' */



  /* DataTypeConversion: '<S603>/Data Type Conversion2' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o3_cc;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion2_nq = starting_index;



  /* End of DataTypeConversion: '<S603>/Data Type Conversion2' */



  /* DataTypeConversion: '<S603>/Data Type Conversion3' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o4_ok;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion3_dq = starting_index;



  /* End of DataTypeConversion: '<S603>/Data Type Conversion3' */



  /* DataTypeConversion: '<S603>/Data Type Conversion4' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o5_m;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion4_j2 = starting_index;



  /* End of DataTypeConversion: '<S603>/Data Type Conversion4' */



  /* DataTypeConversion: '<S603>/Data Type Conversion5' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o6_p;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion5_gc = starting_index;



  /* End of DataTypeConversion: '<S603>/Data Type Conversion5' */



  /* DataTypeConversion: '<S603>/Data Type Conversion6' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o7_pe;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion6_m = starting_index;



  /* End of DataTypeConversion: '<S603>/Data Type Conversion6' */



  /* DataTypeConversion: '<S603>/Data Type Conversion7' */

  PositionFinalLimited = L4_MABX_B.SFunction1_o8_o;

  if (PositionFinalLimited < 256.0) {

    if (PositionFinalLimited >= 0.0) {

      starting_index = (uint8_T)PositionFinalLimited;

    } else {

      starting_index = 0U;

    }

  } else {

    starting_index = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion7_p = starting_index;



  /* End of DataTypeConversion: '<S603>/Data Type Conversion7' */



  /* MultiPortSwitch: '<S451>/Multiport_Switch' incorporates:

   *  Constant: '<S451>/Constant'

   */

  switch (PROPB_REAX_CHANNEL_APV) {

   case ENUM_CAN_RX_T_RX_CAN_1:

    /* DataTypeConversion: '<S601>/Data Type Conversion' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o1_nw;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion_ar = starting_index;



    /* End of DataTypeConversion: '<S601>/Data Type Conversion' */



    /* DataTypeConversion: '<S601>/Data Type Conversion1' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o2_bx;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion1_jj = starting_index;



    /* End of DataTypeConversion: '<S601>/Data Type Conversion1' */



    /* DataTypeConversion: '<S601>/Data Type Conversion2' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o3_hu;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion2_a2z = starting_index;



    /* End of DataTypeConversion: '<S601>/Data Type Conversion2' */



    /* DataTypeConversion: '<S601>/Data Type Conversion3' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o4_i2;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion3_mn = starting_index;



    /* End of DataTypeConversion: '<S601>/Data Type Conversion3' */



    /* DataTypeConversion: '<S601>/Data Type Conversion4' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o5_mc;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion4_dr = starting_index;



    /* End of DataTypeConversion: '<S601>/Data Type Conversion4' */



    /* DataTypeConversion: '<S601>/Data Type Conversion5' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o6_bm;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion5_kq = starting_index;



    /* End of DataTypeConversion: '<S601>/Data Type Conversion5' */



    /* DataTypeConversion: '<S601>/Data Type Conversion6' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o7_p0;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion6_fx = starting_index;



    /* End of DataTypeConversion: '<S601>/Data Type Conversion6' */



    /* DataTypeConversion: '<S601>/Data Type Conversion7' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o8_j;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion7_b = starting_index;



    /* End of DataTypeConversion: '<S601>/Data Type Conversion7' */

    L4_MABX_B.RawData_m[0] = L4_MABX_B.DataTypeConversion_ar;

    L4_MABX_B.RawData_m[1] = L4_MABX_B.DataTypeConversion1_jj;

    L4_MABX_B.RawData_m[2] = L4_MABX_B.DataTypeConversion2_a2z;

    L4_MABX_B.RawData_m[3] = L4_MABX_B.DataTypeConversion3_mn;

    L4_MABX_B.RawData_m[4] = L4_MABX_B.DataTypeConversion4_dr;

    L4_MABX_B.RawData_m[5] = L4_MABX_B.DataTypeConversion5_kq;

    L4_MABX_B.RawData_m[6] = L4_MABX_B.DataTypeConversion6_fx;

    L4_MABX_B.RawData_m[7] = L4_MABX_B.DataTypeConversion7_b;

    break;



   case ENUM_CAN_RX_T_RX_CAN_2:

    /* DataTypeConversion: '<S602>/Data Type Conversion' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o1_dc;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion_bo = starting_index;



    /* End of DataTypeConversion: '<S602>/Data Type Conversion' */



    /* DataTypeConversion: '<S602>/Data Type Conversion1' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o2_bu;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion1_d = starting_index;



    /* End of DataTypeConversion: '<S602>/Data Type Conversion1' */



    /* DataTypeConversion: '<S602>/Data Type Conversion2' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o3_mi;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion2_fk = starting_index;



    /* End of DataTypeConversion: '<S602>/Data Type Conversion2' */



    /* DataTypeConversion: '<S602>/Data Type Conversion3' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o4_hm;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion3_en = starting_index;



    /* End of DataTypeConversion: '<S602>/Data Type Conversion3' */



    /* DataTypeConversion: '<S602>/Data Type Conversion4' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o5_bl;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion4_g2 = starting_index;



    /* End of DataTypeConversion: '<S602>/Data Type Conversion4' */



    /* DataTypeConversion: '<S602>/Data Type Conversion5' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o6_e;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion5_e = starting_index;



    /* End of DataTypeConversion: '<S602>/Data Type Conversion5' */



    /* DataTypeConversion: '<S602>/Data Type Conversion6' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o7_cl;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion6_da = starting_index;



    /* End of DataTypeConversion: '<S602>/Data Type Conversion6' */



    /* DataTypeConversion: '<S602>/Data Type Conversion7' */

    PositionFinalLimited = L4_MABX_B.SFunction1_o8_d;

    if (PositionFinalLimited < 256.0) {

      if (PositionFinalLimited >= 0.0) {

        starting_index = (uint8_T)PositionFinalLimited;

      } else {

        starting_index = 0U;

      }

    } else {

      starting_index = MAX_uint8_T;

    }



    L4_MABX_B.DataTypeConversion7_h = starting_index;



    /* End of DataTypeConversion: '<S602>/Data Type Conversion7' */

    L4_MABX_B.RawData_m[0] = L4_MABX_B.DataTypeConversion_bo;

    L4_MABX_B.RawData_m[1] = L4_MABX_B.DataTypeConversion1_d;

    L4_MABX_B.RawData_m[2] = L4_MABX_B.DataTypeConversion2_fk;

    L4_MABX_B.RawData_m[3] = L4_MABX_B.DataTypeConversion3_en;

    L4_MABX_B.RawData_m[4] = L4_MABX_B.DataTypeConversion4_g2;

    L4_MABX_B.RawData_m[5] = L4_MABX_B.DataTypeConversion5_e;

    L4_MABX_B.RawData_m[6] = L4_MABX_B.DataTypeConversion6_da;

    L4_MABX_B.RawData_m[7] = L4_MABX_B.DataTypeConversion7_h;

    break;



   case ENUM_CAN_RX_T_RX_CAN_3:

    L4_MABX_B.RawData_m[0] = L4_MABX_B.DataTypeConversion_ll;

    L4_MABX_B.RawData_m[1] = L4_MABX_B.DataTypeConversion1_ow;

    L4_MABX_B.RawData_m[2] = L4_MABX_B.DataTypeConversion2_nq;

    L4_MABX_B.RawData_m[3] = L4_MABX_B.DataTypeConversion3_dq;

    L4_MABX_B.RawData_m[4] = L4_MABX_B.DataTypeConversion4_j2;

    L4_MABX_B.RawData_m[5] = L4_MABX_B.DataTypeConversion5_gc;

    L4_MABX_B.RawData_m[6] = L4_MABX_B.DataTypeConversion6_m;

    L4_MABX_B.RawData_m[7] = L4_MABX_B.DataTypeConversion7_p;

    break;



   case ENUM_CAN_RX_T_RX_CAN_4:

    L4_MABX_B.RawData_m[0] = L4_MABX_B.DataTypeConversion_ll;

    L4_MABX_B.RawData_m[1] = L4_MABX_B.DataTypeConversion1_ow;

    L4_MABX_B.RawData_m[2] = L4_MABX_B.DataTypeConversion2_nq;

    L4_MABX_B.RawData_m[3] = L4_MABX_B.DataTypeConversion3_dq;

    L4_MABX_B.RawData_m[4] = L4_MABX_B.DataTypeConversion4_j2;

    L4_MABX_B.RawData_m[5] = L4_MABX_B.DataTypeConversion5_gc;

    L4_MABX_B.RawData_m[6] = L4_MABX_B.DataTypeConversion6_m;

    L4_MABX_B.RawData_m[7] = L4_MABX_B.DataTypeConversion7_p;

    break;



   case ENUM_CAN_RX_T_RX_CAN_5:

    L4_MABX_B.RawData_m[0] = L4_MABX_B.DataTypeConversion_ll;

    L4_MABX_B.RawData_m[1] = L4_MABX_B.DataTypeConversion1_ow;

    L4_MABX_B.RawData_m[2] = L4_MABX_B.DataTypeConversion2_nq;

    L4_MABX_B.RawData_m[3] = L4_MABX_B.DataTypeConversion3_dq;

    L4_MABX_B.RawData_m[4] = L4_MABX_B.DataTypeConversion4_j2;

    L4_MABX_B.RawData_m[5] = L4_MABX_B.DataTypeConversion5_gc;

    L4_MABX_B.RawData_m[6] = L4_MABX_B.DataTypeConversion6_m;

    L4_MABX_B.RawData_m[7] = L4_MABX_B.DataTypeConversion7_p;

    break;



   case ENUM_CAN_RX_T_RX_CAN_6:

    L4_MABX_B.RawData_m[0] = L4_MABX_B.DataTypeConversion_ll;

    L4_MABX_B.RawData_m[1] = L4_MABX_B.DataTypeConversion1_ow;

    L4_MABX_B.RawData_m[2] = L4_MABX_B.DataTypeConversion2_nq;

    L4_MABX_B.RawData_m[3] = L4_MABX_B.DataTypeConversion3_dq;

    L4_MABX_B.RawData_m[4] = L4_MABX_B.DataTypeConversion4_j2;

    L4_MABX_B.RawData_m[5] = L4_MABX_B.DataTypeConversion5_gc;

    L4_MABX_B.RawData_m[6] = L4_MABX_B.DataTypeConversion6_m;

    L4_MABX_B.RawData_m[7] = L4_MABX_B.DataTypeConversion7_p;

    break;



   default:

    L4_MABX_B.RawData_m[0] = L4_MABX_B.DataTypeConversion_ll;

    L4_MABX_B.RawData_m[1] = L4_MABX_B.DataTypeConversion1_ow;

    L4_MABX_B.RawData_m[2] = L4_MABX_B.DataTypeConversion2_nq;

    L4_MABX_B.RawData_m[3] = L4_MABX_B.DataTypeConversion3_dq;

    L4_MABX_B.RawData_m[4] = L4_MABX_B.DataTypeConversion4_j2;

    L4_MABX_B.RawData_m[5] = L4_MABX_B.DataTypeConversion5_gc;

    L4_MABX_B.RawData_m[6] = L4_MABX_B.DataTypeConversion6_m;

    L4_MABX_B.RawData_m[7] = L4_MABX_B.DataTypeConversion7_p;

    break;

  }



  /* S-Function (sfix_bitop): '<S690>/Operator' */

  L4_MABX_B.Operator_fc = (uint8_T)(L4_MABX_B.RawData_m[0] &

    L4_MABX_P.Operator_BitMask_m);



  /* DataTypeConversion: '<S690>/DataType' */

  L4_MABX_B.DataType_hz = L4_MABX_B.Operator_fc;



  /* ArithShift: '<S683>/Shift_Arithmetic ' */

  L4_MABX_B.Shift_Arithmetic_ck = (uint8_T)((uint32_T)L4_MABX_B.DataType_hz >> 1);



  /* DataTypeConversion: '<S683>/Data Type Conversion' */

  L4_MABX_B.PropB_REAX_4_PositionIndexValid = (L4_MABX_B.Shift_Arithmetic_ck !=

    0);



  /* DataTypeConversion: '<S426>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_bi = L4_MABX_B.PropB_REAX_4_PositionIndexValid;



  /* S-Function (sfix_bitop): '<S689>/Operator' */

  L4_MABX_B.Operator_mc = (uint8_T)(L4_MABX_B.RawData_m[0] &

    L4_MABX_P.Operator_BitMask_f);



  /* DataTypeConversion: '<S689>/DataType' */

  L4_MABX_B.DataType_pb = (L4_MABX_B.Operator_mc != 0);



  /* DataTypeConversion: '<S426>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_c5 = L4_MABX_B.DataType_pb;



  /* S-Function (sfix_bitop): '<S691>/Operator' */

  L4_MABX_B.Operator_nt = (uint8_T)(L4_MABX_B.RawData_m[0] &

    L4_MABX_P.Operator_BitMask_i3);



  /* DataTypeConversion: '<S691>/DataType' */

  L4_MABX_B.DataType_fo = L4_MABX_B.Operator_nt;



  /* ArithShift: '<S683>/Shift_Arithmetic 1' */

  L4_MABX_B.Shift_Arithmetic1_gi = (uint8_T)((uint32_T)L4_MABX_B.DataType_fo >>

    2);



  /* DataTypeConversion: '<S683>/Data Type Conversion1' */

  L4_MABX_B.PropB_REAX_4_DriverControlledEf = (L4_MABX_B.Shift_Arithmetic1_gi !=

    0);



  /* DataTypeConversion: '<S426>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_hs = L4_MABX_B.PropB_REAX_4_DriverControlledEf;



  /* SignalConversion: '<S684>/SignalConversion' */

  L4_MABX_B.PropB_REAX_4_ControlOperatingMo = L4_MABX_B.RawData_m[1];



  /* DataTypeConversion: '<S426>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_c = L4_MABX_B.PropB_REAX_4_ControlOperatingMo;



  /* SignalConversion: '<S685>/SignalConversion' */

  L4_MABX_B.PropB_REAX_4_SystemMode = L4_MABX_B.RawData_m[2];



  /* DataTypeConversion: '<S426>/Data Type Conversion4' */

  L4_MABX_B.DataTypeConversion4_au = L4_MABX_B.PropB_REAX_4_SystemMode;



  /* DataTypeConversion: '<S686>/Data Type Conversion4' */

  L4_MABX_B.DataTypeConversion4_mz = (int8_T)L4_MABX_B.RawData_m[4];



  /* DataTypeConversion: '<S686>/Data Type Conversion5' */

  L4_MABX_B.PropB_REAX_4_PercHandwheelTorqu = L4_MABX_B.DataTypeConversion4_mz;



  /* DataTypeConversion: '<S426>/Data Type Conversion5' */

  L4_MABX_B.DataTypeConversion5_m = L4_MABX_B.PropB_REAX_4_PercHandwheelTorqu;



  /* DataTypeConversion: '<S687>/Data Type Conversion6' */

  L4_MABX_B.DataTypeConversion6_h0 = L4_MABX_B.RawData_m[5];



  /* DataTypeConversion: '<S687>/Data Type Conversion7' */

  L4_MABX_B.DataTypeConversion7_c = L4_MABX_B.RawData_m[6];



  /* ArithShift: '<S687>/Shift_Arithmetic 2' */

  L4_MABX_B.Shift_Arithmetic2_p = (uint16_T)(L4_MABX_B.DataTypeConversion7_c <<

    8);



  /* S-Function (sfix_bitop): '<S692>/Operator' */

  L4_MABX_B.Operator_if = (uint16_T)(L4_MABX_B.DataTypeConversion6_h0 |

    L4_MABX_B.Shift_Arithmetic2_p);



  /* DataTypeConversion: '<S692>/DataType' */

  L4_MABX_B.DataType_cz = L4_MABX_B.Operator_if;



  /* DataTypeConversion: '<S687>/Data Type Conversion8' */

  L4_MABX_B.DataTypeConversion8_b = (int16_T)L4_MABX_B.DataType_cz;



  /* DataTypeConversion: '<S687>/Data Type Conversion9' */

  L4_MABX_B.PropB_REAX_4_AbsSteeringAngle = L4_MABX_B.DataTypeConversion8_b;



  /* DataTypeConversion: '<S426>/Data Type Conversion6' */

  L4_MABX_B.DataTypeConversion6_b = L4_MABX_B.PropB_REAX_4_AbsSteeringAngle;



  /* DataTypeConversion: '<S688>/Data Type Conversion10' */

  L4_MABX_B.DataTypeConversion10_fy = (int8_T)L4_MABX_B.RawData_m[7];



  /* DataTypeConversion: '<S688>/Data Type Conversion11' */

  L4_MABX_B.PropB_REAX_4_PercMotorTorque = L4_MABX_B.DataTypeConversion10_fy;



  /* DataTypeConversion: '<S426>/Data Type Conversion7' */

  L4_MABX_B.DataTypeConversion7_l = L4_MABX_B.PropB_REAX_4_PercMotorTorque;



  /* DataTypeConversion: '<S603>/Data Type Conversion8' */

  L4_MABX_B.RX_status_g3 = (L4_MABX_B.SFunction1_o9_h != 0.0);



  /* MultiPortSwitch: '<S451>/Multiport_Switch' incorporates:

   *  Constant: '<S451>/Constant'

   */

  switch (PROPB_REAX_CHANNEL_APV) {

   case ENUM_CAN_RX_T_RX_CAN_1:

    /* DataTypeConversion: '<S601>/Data Type Conversion8' */

    L4_MABX_B.RX_status_b5 = (L4_MABX_B.SFunction1_o9_e != 0.0);

    L4_MABX_B.RX_status_ni = L4_MABX_B.RX_status_b5;

    break;



   case ENUM_CAN_RX_T_RX_CAN_2:

    /* DataTypeConversion: '<S602>/Data Type Conversion8' */

    L4_MABX_B.RX_status_io = (L4_MABX_B.SFunction1_o9_o != 0.0);

    L4_MABX_B.RX_status_ni = L4_MABX_B.RX_status_io;

    break;



   case ENUM_CAN_RX_T_RX_CAN_3:

    L4_MABX_B.RX_status_ni = L4_MABX_B.RX_status_g3;

    break;



   case ENUM_CAN_RX_T_RX_CAN_4:

    L4_MABX_B.RX_status_ni = L4_MABX_B.RX_status_g3;

    break;



   case ENUM_CAN_RX_T_RX_CAN_5:

    L4_MABX_B.RX_status_ni = L4_MABX_B.RX_status_g3;

    break;



   case ENUM_CAN_RX_T_RX_CAN_6:

    L4_MABX_B.RX_status_ni = L4_MABX_B.RX_status_g3;

    break;



   default:

    L4_MABX_B.RX_status_ni = L4_MABX_B.RX_status_g3;

    break;

  }



  /* DataTypeConversion: '<S603>/Data Type Conversion9' */

  L4_MABX_B.RX_time_c4 = L4_MABX_B.SFunction1_o10_c;



  /* MultiPortSwitch: '<S451>/Multiport_Switch' incorporates:

   *  Constant: '<S451>/Constant'

   */

  switch (PROPB_REAX_CHANNEL_APV) {

   case ENUM_CAN_RX_T_RX_CAN_1:

    /* DataTypeConversion: '<S601>/Data Type Conversion9' */

    L4_MABX_B.RX_time_b2 = L4_MABX_B.SFunction1_o10_a;

    L4_MABX_B.RX_time_pm = L4_MABX_B.RX_time_b2;

    break;



   case ENUM_CAN_RX_T_RX_CAN_2:

    /* DataTypeConversion: '<S602>/Data Type Conversion9' */

    L4_MABX_B.RX_time_ic = L4_MABX_B.SFunction1_o10_p;

    L4_MABX_B.RX_time_pm = L4_MABX_B.RX_time_ic;

    break;



   case ENUM_CAN_RX_T_RX_CAN_3:

    L4_MABX_B.RX_time_pm = L4_MABX_B.RX_time_c4;

    break;



   case ENUM_CAN_RX_T_RX_CAN_4:

    L4_MABX_B.RX_time_pm = L4_MABX_B.RX_time_c4;

    break;



   case ENUM_CAN_RX_T_RX_CAN_5:

    L4_MABX_B.RX_time_pm = L4_MABX_B.RX_time_c4;

    break;



   case ENUM_CAN_RX_T_RX_CAN_6:

    L4_MABX_B.RX_time_pm = L4_MABX_B.RX_time_c4;

    break;



   default:

    L4_MABX_B.RX_time_pm = L4_MABX_B.RX_time_c4;

    break;

  }



  /* DataTypeConversion: '<S603>/Data Type Conversion10' */

  L4_MABX_B.RX_delta_time_hc = L4_MABX_B.SFunction1_o11_a;



  /* MultiPortSwitch: '<S451>/Multiport_Switch' incorporates:

   *  Constant: '<S451>/Constant'

   */

  switch (PROPB_REAX_CHANNEL_APV) {

   case ENUM_CAN_RX_T_RX_CAN_1:

    /* DataTypeConversion: '<S601>/Data Type Conversion10' */

    L4_MABX_B.RX_delta_time_f = L4_MABX_B.SFunction1_o11_f;

    L4_MABX_B.RX_delta_time_bo = L4_MABX_B.RX_delta_time_f;

    break;



   case ENUM_CAN_RX_T_RX_CAN_2:

    /* DataTypeConversion: '<S602>/Data Type Conversion10' */

    L4_MABX_B.RX_delta_time_mv = L4_MABX_B.SFunction1_o11_g;

    L4_MABX_B.RX_delta_time_bo = L4_MABX_B.RX_delta_time_mv;

    break;



   case ENUM_CAN_RX_T_RX_CAN_3:

    L4_MABX_B.RX_delta_time_bo = L4_MABX_B.RX_delta_time_hc;

    break;



   case ENUM_CAN_RX_T_RX_CAN_4:

    L4_MABX_B.RX_delta_time_bo = L4_MABX_B.RX_delta_time_hc;

    break;



   case ENUM_CAN_RX_T_RX_CAN_5:

    L4_MABX_B.RX_delta_time_bo = L4_MABX_B.RX_delta_time_hc;

    break;



   case ENUM_CAN_RX_T_RX_CAN_6:

    L4_MABX_B.RX_delta_time_bo = L4_MABX_B.RX_delta_time_hc;

    break;



   default:

    L4_MABX_B.RX_delta_time_bo = L4_MABX_B.RX_delta_time_hc;

    break;

  }



  /* RelationalOperator: '<S610>/Operator' incorporates:

   *  Constant: '<S451>/Constant'

   *  Constant: '<S604>/Constant2'

   */

  L4_MABX_B.Operator_ft = (PROPB_REAX_CHANNEL_APV ==

    L4_MABX_P.Constant2_Value_gx);



  /* RelationalOperator: '<S611>/Operator' incorporates:

   *  Constant: '<S451>/Constant'

   *  Constant: '<S604>/Constant3'

   */

  L4_MABX_B.Operator_f21 = (PROPB_REAX_CHANNEL_APV ==

    L4_MABX_P.Constant3_Value_k);



  /* RelationalOperator: '<S612>/Operator' incorporates:

   *  Constant: '<S451>/Constant'

   *  Constant: '<S604>/Constant4'

   */

  L4_MABX_B.Operator_ev0 = (PROPB_REAX_CHANNEL_APV ==

    L4_MABX_P.Constant4_Value_a);



  /* S-Function (rti_commonblock): '<S466>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* S-Function (rti_commonblock): '<S467>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* S-Function (rti_commonblock): '<S468>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* S-Function (rti_commonblock): '<S469>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* S-Function (rti_commonblock): '<S470>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* S-Function (rti_commonblock): '<S471>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* S-Function (rti_commonblock): '<S743>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* DataTypeConversion: '<S422>/LogPbActive' */

  L4_MABX_B.LogPbActive = L4_MABX_B.SFunction1_g;



  /* Logic: '<S422>/Logical Operator2' */

  L4_MABX_B.LogicalOperator2_l = !L4_MABX_B.LogPbActive;



  /* RelationalOperator: '<S757>/Compare' incorporates:

   *  Constant: '<S757>/Constant'

   */

  L4_MABX_B.Compare_ai = ((int32_T)L4_MABX_B.LogicalOperator2_l > (int32_T)

    L4_MABX_P.Constant_Value_lq);



  /* UnitDelay: '<S753>/Delay Input1' */

  L4_MABX_B.Uk1_kx = L4_MABX_DW.DelayInput1_DSTATE_l;



  /* RelationalOperator: '<S753>/FixPt Relational Operator' */

  L4_MABX_B.FixPtRelationalOperator_f = ((int32_T)L4_MABX_B.Compare_ai >

    (int32_T)L4_MABX_B.Uk1_kx);



  /* UnitDelay: '<S754>/Unit Delay' */

  L4_MABX_B.UnitDelay_c = L4_MABX_DW.UnitDelay_DSTATE_j;



  /* UnitDelay: '<S748>/Unit Delay' */

  L4_MABX_B.UnitDelay_os = L4_MABX_DW.UnitDelay_DSTATE_cq;



  /* RelationalOperator: '<S756>/Compare' incorporates:

   *  Constant: '<S756>/Constant'

   */

  L4_MABX_B.Compare_b = ((int32_T)L4_MABX_B.UnitDelay_os <= (int32_T)

    L4_MABX_P.Constant_Value_eyi);



  /* UnitDelay: '<S752>/Delay Input1' */

  L4_MABX_B.Uk1_i = L4_MABX_DW.DelayInput1_DSTATE_c;



  /* RelationalOperator: '<S752>/FixPt Relational Operator' */

  L4_MABX_B.FixPtRelationalOperator_no = ((int32_T)L4_MABX_B.Compare_b >

    (int32_T)L4_MABX_B.Uk1_i);



  /* UnitDelay: '<S754>/Unit Delay1' */

  L4_MABX_B.UnitDelay1_co = L4_MABX_DW.UnitDelay1_DSTATE_n;



  /* Logic: '<S754>/OR1' */

  L4_MABX_B.OR1_mk = (L4_MABX_B.FixPtRelationalOperator_no ||

                      L4_MABX_B.UnitDelay1_co);



  /* Switch: '<S754>/Switch' incorporates:

   *  Constant: '<S754>/Constant0'

   */

  if (L4_MABX_B.OR1_mk) {

    /* Sum: '<S754>/Sum' incorporates:

     *  Constant: '<S754>/Constant1'

     */

    L4_MABX_B.Sum_b = L4_MABX_B.UnitDelay_c + L4_MABX_P.Constant1_Value_ma;

    L4_MABX_B.Switch_m = L4_MABX_B.Sum_b;

  } else {

    L4_MABX_B.Switch_m = L4_MABX_P.Constant0_Value_n;

  }



  /* End of Switch: '<S754>/Switch' */



  /* RelationalOperator: '<S758>/Compare' incorporates:

   *  Constant: '<S758>/Constant'

   */

  L4_MABX_B.Compare_mn = (L4_MABX_B.Switch_m > L4_MABX_P.Constant_Value_i4);



  /* Gain: '<S754>/Gain' incorporates:

   *  Constant: '<S422>/Constant1'

   */

  L4_MABX_B.Gain_f = L4_MABX_P.Gain_Gain_f3 * L4_MABX_P.Constant1_Value_fq;



  /* RelationalOperator: '<S754>/LessThanOrEqual' */

  L4_MABX_B.LessThanOrEqual_i = (L4_MABX_B.Switch_m <= L4_MABX_B.Gain_f);



  /* Logic: '<S754>/AND' */

  L4_MABX_B.AND_d = (L4_MABX_B.Compare_mn && L4_MABX_B.LessThanOrEqual_i);



  /* Logic: '<S748>/NOT' */

  L4_MABX_B.NOT_k = !L4_MABX_B.AND_d;



  /* Logic: '<S748>/AND' */

  L4_MABX_B.AND_d2 = (L4_MABX_B.FixPtRelationalOperator_f && L4_MABX_B.NOT_k);



  /* UnitDelay: '<S755>/Unit Delay' */

  L4_MABX_B.UnitDelay_m = L4_MABX_DW.UnitDelay_DSTATE_is;



  /* UnitDelay: '<S755>/Unit Delay1' */

  L4_MABX_B.UnitDelay1_i = L4_MABX_DW.UnitDelay1_DSTATE_pn;



  /* Logic: '<S755>/OR1' */

  L4_MABX_B.OR1_k = (L4_MABX_B.AND_d2 || L4_MABX_B.UnitDelay1_i);



  /* Switch: '<S755>/Switch' incorporates:

   *  Constant: '<S755>/Constant0'

   */

  if (L4_MABX_B.OR1_k) {

    /* Sum: '<S755>/Sum' incorporates:

     *  Constant: '<S755>/Constant1'

     */

    L4_MABX_B.Sum_g = L4_MABX_B.UnitDelay_m + L4_MABX_P.Constant1_Value_eu;

    L4_MABX_B.Switch_h = L4_MABX_B.Sum_g;

  } else {

    L4_MABX_B.Switch_h = L4_MABX_P.Constant0_Value_l;

  }



  /* End of Switch: '<S755>/Switch' */



  /* RelationalOperator: '<S759>/Compare' incorporates:

   *  Constant: '<S759>/Constant'

   */

  L4_MABX_B.Compare_bm = (L4_MABX_B.Switch_h > L4_MABX_P.Constant_Value_m4);



  /* Gain: '<S755>/Gain' incorporates:

   *  Constant: '<S422>/Constant'

   */

  L4_MABX_B.Gain_f1 = L4_MABX_P.Gain_Gain_ph * L4_MABX_P.Constant_Value_ey;



  /* RelationalOperator: '<S755>/LessThanOrEqual' */

  L4_MABX_B.LessThanOrEqual_j = (L4_MABX_B.Switch_h <= L4_MABX_B.Gain_f1);



  /* Logic: '<S755>/AND' */

  L4_MABX_B.AND_j = (L4_MABX_B.Compare_bm && L4_MABX_B.LessThanOrEqual_j);



  /* Logic: '<S748>/AND2' */

  LogEventPB = (L4_MABX_B.AND_j && L4_MABX_B.NOT_k);



  /* Assertion: '<S789>/Assertion' */

  utAssert(L4_MABX_B.conjunction_p);



  /* Assertion: '<S797>/Assertion' */

  utAssert(L4_MABX_B.conjunction);



  /* Assertion: '<S805>/Assertion' */

  utAssert(L4_MABX_B.conjunction_d);



  /* Assertion: '<S813>/Assertion' */

  utAssert(L4_MABX_B.conjunction_f);



  /* Assertion: '<S821>/Assertion' */

  utAssert(L4_MABX_B.conjunction_h);



  /* RelationalOperator: '<S788>/Relational Operator9' incorporates:

   *  Constant: '<S769>/PWMSynchFaultLimMin'

   */

  L4_MABX_B.F_Fault_Soft_cn = (L4_MABX_B.If_Then_Else_j.Switch !=

    L4_MABX_P.PWMSynchFaultLimMin_Value);



  /* Gain: '<S422>/ShifterControlFreq' */

  L4_MABX_B.ShiftControlFreq = L4_MABX_P.ShifterControlFreq_Gain *

    L4_MABX_B.SFunction1_o1_f;



  /* S-Function (rti_commonblock): '<S736>/S-Function1' */

  /* This comment workarounds a code generation problem */

  {

    /* dSPACE I/O Board DS1401STDADCT4 #1 Unit:ADC Group:ADC */

    adc_tp4_single_new_read(ADC_TP4_1_MODULE_ADDR,

      ADC_TP4_CH2,

      (dsfloat *)&L4_MABX_B.SFunction1_n);

  }



  /* Gain: '<S422>/ShifterControlDC2' */

  L4_MABX_B.ShifterControlDC2 = L4_MABX_P.ShifterControlDC2_Gain *

    L4_MABX_B.SFunction1_n;



  /* S-Function (rti_commonblock): '<S737>/S-Function1' */

  /* This comment workarounds a code generation problem */

  {

    /* dSPACE I/O Board DS1401STDADCT4 #1 Unit:ADC Group:ADC */

    adc_tp4_single_new_read(ADC_TP4_1_MODULE_ADDR,

      ADC_TP4_CH1,

      (dsfloat *)&L4_MABX_B.SFunction1_b);

  }



  /* Gain: '<S422>/ShifterControlDC1' */

  L4_MABX_B.ShifterControlDC1 = L4_MABX_P.ShifterControlDC1_Gain *

    L4_MABX_B.SFunction1_b;



  /* S-Function (rti_commonblock): '<S8>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* S-Function (rti_commonblock): '<S9>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* UnitDelay: '<S10>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_jj = L4_MABX_DW.Unit_Delay_DSTATE_do;



  /* Outputs for Enabled SubSystem: '<S10>/EnabledSubsystem' incorporates:

   *  EnablePort: '<S1096>/Enable'

   */

  if (L4_MABX_B.Unit_Delay_jj) {

    /* Constant: '<S1096>/Constant' */

    memcpy(&GLB_SWVERSION_CPV_[0], &L4_MABX_P.GLB_SWVERSION_CPV[0], 100U *

           sizeof(uint8_T));

  }



  /* End of Outputs for SubSystem: '<S10>/EnabledSubsystem' */

  /* user code (Output function Trailer for TID0) */



  /* XCP Data Capture block: <Root>/RTIEthXCP Data Capture */

  /* EventChannel: 0 */

  if (tid == 0) {

    DSXCP_service(0);

  }



  /* If subsystem generates rate grouping Output functions,

   * when tid is used in Output function for one rate,

   * all Output functions include tid as a local variable.

   * As result, some Output functions may have unused tid.

   */

  UNUSED_PARAMETER(tid);

}



/* Model update function for TID0 */

void L4_MABX_update0(void)             /* Sample time: [0.01s, 0.0s] */

{

  int32_T i;



  /* Update for UnitDelay: '<S763>/Unit Delay' */

  L4_MABX_DW.UnitDelay_DSTATE = L4_MABX_B.Switch_j;



  /* Update for UnitDelay: '<S761>/Delay Input1' */

  L4_MABX_DW.DelayInput1_DSTATE_i = L4_MABX_B.Compare;



  /* Update for UnitDelay: '<S762>/Unit Delay' */

  L4_MABX_DW.UnitDelay_DSTATE_i = L4_MABX_B.Switch;



  /* Update for UnitDelay: '<S749>/Unit Delay' */

  L4_MABX_DW.UnitDelay_DSTATE_ix = L4_MABX_B.AND_i;



  /* Update for UnitDelay: '<S760>/Delay Input1' */

  L4_MABX_DW.DelayInput1_DSTATE_i5 = L4_MABX_B.Compare_p;



  /* Update for UnitDelay: '<S762>/Unit Delay1' */

  L4_MABX_DW.UnitDelay1_DSTATE_p = L4_MABX_B.AND;



  /* Update for UnitDelay: '<S763>/Unit Delay1' */

  L4_MABX_DW.UnitDelay1_DSTATE_h = L4_MABX_B.AND_i;



  /* Update for UnitDelay: '<S802>/FixPt Unit Delay2' incorporates:

   *  Constant: '<S802>/FixPt Constant'

   */

  L4_MABX_DW.FixPtUnitDelay2_DSTATE = L4_MABX_P.FixPtConstant_Value_nv;



  /* Update for UnitDelay: '<S802>/FixPt Unit Delay1' */

  L4_MABX_DW.FixPtUnitDelay1_DSTATE = L4_MABX_B.If_Then_Else_a.Switch;



  /* Update for UnitDelay: '<S794>/FixPt Unit Delay2' incorporates:

   *  Constant: '<S794>/FixPt Constant'

   */

  L4_MABX_DW.FixPtUnitDelay2_DSTATE_d = L4_MABX_P.FixPtConstant_Value_l;



  /* Update for UnitDelay: '<S794>/FixPt Unit Delay1' */

  L4_MABX_DW.FixPtUnitDelay1_DSTATE_d = L4_MABX_B.If_Then_Else_h.Switch;



  /* Update for UnitDelay: '<S818>/FixPt Unit Delay2' incorporates:

   *  Constant: '<S818>/FixPt Constant'

   */

  L4_MABX_DW.FixPtUnitDelay2_DSTATE_a = L4_MABX_P.FixPtConstant_Value_od;



  /* Update for UnitDelay: '<S818>/FixPt Unit Delay1' */

  L4_MABX_DW.FixPtUnitDelay1_DSTATE_g = L4_MABX_B.If_Then_Else_p.Switch;



  /* Update for UnitDelay: '<S810>/FixPt Unit Delay2' incorporates:

   *  Constant: '<S810>/FixPt Constant'

   */

  L4_MABX_DW.FixPtUnitDelay2_DSTATE_i = L4_MABX_P.FixPtConstant_Value_kl;



  /* Update for UnitDelay: '<S810>/FixPt Unit Delay1' */

  L4_MABX_DW.FixPtUnitDelay1_DSTATE_e = L4_MABX_B.If_Then_Else_k.Switch;



  /* Update for UnitDelay: '<S772>/Unit_Delay' incorporates:

   *  Constant: '<S772>/Constant'

   */

  L4_MABX_DW.Unit_Delay_DSTATE_pw = L4_MABX_P.Constant_Value_la;



  /* Update for UnitDelay: '<S839>/Unit_Delay1' incorporates:

   *  Constant: '<S839>/Constant'

   */

  L4_MABX_DW.Unit_Delay1_DSTATE = L4_MABX_P.Constant_Value_e4;



  /* Update for UnitDelay: '<S839>/Unit_Delay2' */

  L4_MABX_DW.Unit_Delay2_DSTATE = L4_MABX_B.If_Then_Else_i.Switch;



  /* Update for UnitDelay: '<S772>/Unit_Delay1' incorporates:

   *  Constant: '<S772>/Constant1'

   */

  L4_MABX_DW.Unit_Delay1_DSTATE_m = L4_MABX_P.Constant1_Value_pd;



  /* Update for UnitDelay: '<S840>/Unit_Delay1' incorporates:

   *  Constant: '<S840>/Constant'

   */

  L4_MABX_DW.Unit_Delay1_DSTATE_p = L4_MABX_P.Constant_Value_ah1;



  /* Update for UnitDelay: '<S840>/Unit_Delay2' */

  L4_MABX_DW.Unit_Delay2_DSTATE_g = L4_MABX_B.If_Then_Else_b.Switch;



  /* Update for UnitDelay: '<S838>/FixPt Unit Delay2' incorporates:

   *  Constant: '<S838>/FixPt Constant'

   */

  L4_MABX_DW.FixPtUnitDelay2_DSTATE_d1 = L4_MABX_P.FixPtConstant_Value_l1;



  /* Update for UnitDelay: '<S838>/FixPt Unit Delay1' */

  L4_MABX_DW.FixPtUnitDelay1_DSTATE_n = L4_MABX_B.If_Then_Else3_c.Switch;



  /* Update for UnitDelay: '<S837>/FixPt Unit Delay2' incorporates:

   *  Constant: '<S837>/FixPt Constant'

   */

  L4_MABX_DW.FixPtUnitDelay2_DSTATE_g = L4_MABX_P.FixPtConstant_Value_na;



  /* Update for UnitDelay: '<S837>/FixPt Unit Delay1' */

  L4_MABX_DW.FixPtUnitDelay1_DSTATE_j = L4_MABX_B.If_Then_Else1_c.Switch;



  /* Update for UnitDelay: '<S826>/FixPt Unit Delay2' incorporates:

   *  Constant: '<S826>/FixPt Constant'

   */

  L4_MABX_DW.FixPtUnitDelay2_DSTATE_k = L4_MABX_P.FixPtConstant_Value_c;



  /* Update for UnitDelay: '<S826>/FixPt Unit Delay1' */

  L4_MABX_DW.FixPtUnitDelay1_DSTATE_e5 = L4_MABX_B.If_Then_Else_j.Switch;



  /* Update for Enabled SubSystem: '<S750>/Slew_at_event' incorporates:

   *  EnablePort: '<S773>/Enable'

   */

  if (L4_MABX_DW.Slew_at_event_MODE) {

    /* Update for UnitDelay: '<S844>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_jr = L4_MABX_B.LogicalOperator6_o;



    /* Update for UnitDelay: '<S845>/Unit_Delay' incorporates:

     *  Constant: '<S845>/Constant'

     */

    L4_MABX_DW.Unit_Delay_DSTATE_jz = L4_MABX_P.Constant_Value_b5;



    /* Update for UnitDelay: '<S848>/FixPt Unit Delay2' incorporates:

     *  Constant: '<S848>/FixPt Constant'

     */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_b = L4_MABX_P.FixPtConstant_Value_ga;



    /* Update for UnitDelay: '<S848>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_o = L4_MABX_B.If_Then_Else_or.Switch;



    /* Update for UnitDelay: '<S843>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_hg = L4_MABX_B.LogicalOperator_np;

  }



  /* End of Update for SubSystem: '<S750>/Slew_at_event' */



  /* Update for Enabled SubSystem: '<S442>/CAN_RX_EC1_00' incorporates:

   *  EnablePort: '<S526>/Enable'

   */

  if (L4_MABX_B.LogicalOperator_iz) {

    /* Update for UnitDelay: '<S526>/Unit Delay' */

    for (i = 0; i < 39; i++) {

      L4_MABX_DW.UnitDelay_DSTATE_b3[i] = L4_MABX_B.Data_d[i];

    }



    /* End of Update for UnitDelay: '<S526>/Unit Delay' */



    /* Update for Enabled SubSystem: '<S526>/Decode' incorporates:

     *  EnablePort: '<S529>/Enable'

     */

    if (L4_MABX_B.RX_status_pz) {

      /* Update for UnitDelay: '<S529>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_i = L4_MABX_B.timeStamp_j;

    }



    /* End of Update for SubSystem: '<S526>/Decode' */

  }



  /* End of Update for SubSystem: '<S442>/CAN_RX_EC1_00' */



  /* Update for UnitDelay: '<S655>/Unit_Delay3' */

  L4_MABX_DW.Unit_Delay3_DSTATE = L4_MABX_B.LogicalOperator2_a;



  /* Update for Enabled SubSystem: '<S465>/CAN_RX_VI_00' incorporates:

   *  EnablePort: '<S654>/Enable'

   */

  if (L4_MABX_B.LogicalOperator_im) {

    /* Update for UnitDelay: '<S654>/Unit Delay' */

    for (i = 0; i < 17; i++) {

      L4_MABX_DW.UnitDelay_DSTATE_o[i] = L4_MABX_B.Data[i];

    }



    /* End of Update for UnitDelay: '<S654>/Unit Delay' */



    /* Update for Enabled SubSystem: '<S654>/Decode' incorporates:

     *  EnablePort: '<S657>/Enable'

     */

    if (L4_MABX_B.RX_status_bk) {

      /* Update for UnitDelay: '<S657>/Unit_Delay' */

      L4_MABX_DW.Unit_Delay_DSTATE_d = L4_MABX_B.timeStamp;

    }



    /* End of Update for SubSystem: '<S654>/Decode' */

  }



  /* End of Update for SubSystem: '<S465>/CAN_RX_VI_00' */



  /* Update for UnitDelay: '<S655>/Unit_Delay' incorporates:

   *  Constant: '<S655>/Constant'

   */

  L4_MABX_DW.Unit_Delay_DSTATE_h1 = L4_MABX_P.Constant_Value_fw;



  /* Update for UnitDelay: '<S661>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_fr = L4_MABX_B.LogicalOperator1_c;



  /* Update for UnitDelay: '<S3>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_80_DSTATE = EStop;

  L4_MABX_DW.Unit_Delay_81_DSTATE = EnableSw;

  L4_MABX_DW.Unit_Delay_48_DSTATE = L4_MABX_B.AND_a;

  L4_MABX_DW.Unit_Delay_83_DSTATE = LogEventPB;

  L4_MABX_DW.Unit_Delay_45_DSTATE = L4_MABX_B.AutonomousEnabled_d;

  L4_MABX_DW.Unit_Delay_47_DSTATE = MABX_Mode;

  L4_MABX_DW.Unit_Delay_84_DSTATE = BrakeSW;



  /* Update for UnitDelay: '<S411>/Delay Input1' */

  L4_MABX_DW.DelayInput1_DSTATE_n = L4_MABX_B.Compare_c;



  /* Update for UnitDelay: '<S409>/Unit Delay' */

  L4_MABX_DW.UnitDelay_DSTATE_k = L4_MABX_B.Count;



  /* Update for Atomic SubSystem: '<S65>/Task_10ms' */

  /* Update for UnitDelay: '<S97>/Unit Delay1' */

  L4_MABX_DW.UnitDelay1_DSTATE_m = L4_MABX_B.Switch_a;



  /* Update for UnitDelay: '<S76>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_fv = L4_MABX_B.AutonomousEnabled_d;



  /* Update for UnitDelay: '<S98>/Delay Input1' */

  L4_MABX_DW.DelayInput1_DSTATE_d = L4_MABX_B.Compare_jp;



  /* Update for UnitDelay: '<S97>/Unit Delay' */

  L4_MABX_DW.UnitDelay_DSTATE_b1 = L4_MABX_B.AND_f;



  /* Update for Enabled SubSystem: '<S79>/Throttle_controller_gov' incorporates:

   *  EnablePort: '<S212>/Enable'

   */

  if (L4_MABX_DW.Throttle_controller_gov_MODE) {

    /* Update for UnitDelay: '<S220>/Unit_Delay1' incorporates:

     *  Constant: '<S220>/Constant3'

     */

    L4_MABX_DW.Unit_Delay1_DSTATE_p1 = L4_MABX_P.Constant3_Value_lp;



    /* Update for UnitDelay: '<S220>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_lq = L4_MABX_B.RelationalOperator_fl;



    /* Update for UnitDelay: '<S247>/Unit_Delay' incorporates:

     *  Constant: '<S247>/Constant'

     */

    L4_MABX_DW.Unit_Delay_DSTATE_be = L4_MABX_P.Constant_Value_ck;



    /* Update for UnitDelay: '<S267>/Unit_Delay1' incorporates:

     *  Constant: '<S267>/Constant'

     */

    L4_MABX_DW.Unit_Delay1_DSTATE_h = L4_MABX_P.Constant_Value_ot;



    /* Update for UnitDelay: '<S268>/Unit_Delay' incorporates:

     *  Constant: '<S268>/Constant'

     */

    L4_MABX_DW.Unit_Delay_DSTATE_fi = L4_MABX_P.Constant_Value_h0;



    /* Update for UnitDelay: '<S272>/FixPt Unit Delay2' incorporates:

     *  Constant: '<S272>/FixPt Constant'

     */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_gq = L4_MABX_P.FixPtConstant_Value_jk;



    /* Update for UnitDelay: '<S272>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_a = L4_MABX_B.If_Then_Else_cp.Switch;



    /* Update for UnitDelay: '<S267>/Unit_Delay2' */

    L4_MABX_DW.Unit_Delay2_DSTATE_m = L4_MABX_B.If_Then_Else_k2.Switch;



    /* Update for Enabled SubSystem: '<S244>/Calculate_D_term' */

    L4__Calculate_D_term_Update(&L4_MABX_B.Calculate_D_term_h,

      &L4_MABX_DW.Calculate_D_term_h, &L4_MABX_P.Calculate_D_term_h);



    /* End of Update for SubSystem: '<S244>/Calculate_D_term' */



    /* Update for UnitDelay: '<S222>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_fz = L4_MABX_B.Add_ds;



    /* Update for Enabled SubSystem: '<S244>/Calculate_I_term' */

    L4__Calculate_I_term_Update(&L4_MABX_B.Calculate_I_term_n,

      &L4_MABX_DW.Calculate_I_term_n, &L4_MABX_P.Calculate_I_term_n);



    /* End of Update for SubSystem: '<S244>/Calculate_I_term' */

  }



  /* End of Update for SubSystem: '<S79>/Throttle_controller_gov' */



  /* Update for Enabled SubSystem: '<S105>/Determine_shift_interlock_brake_pressure_target' incorporates:

   *  EnablePort: '<S184>/Enable'

   */

  if (L4_MABX_DW.Determine_shift_interlock_brake) {

    /* Update for UnitDelay: '<S184>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_o = L4_MABX_B.If_Then_Else_il.Switch;



    /* Update for UnitDelay: '<S194>/Unit_Delay' incorporates:

     *  Constant: '<S194>/Constant'

     */

    L4_MABX_DW.Unit_Delay_DSTATE_ae = L4_MABX_P.Constant_Value_ii;



    /* Update for UnitDelay: '<S198>/FixPt Unit Delay2' incorporates:

     *  Constant: '<S198>/FixPt Constant'

     */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_l = L4_MABX_P.FixPtConstant_Value_kr;



    /* Update for UnitDelay: '<S198>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_ds = L4_MABX_B.If_Then_Else_ep.Switch;



    /* Update for UnitDelay: '<S195>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_om = L4_MABX_B.DigitalClock_e;

  }



  /* End of Update for SubSystem: '<S105>/Determine_shift_interlock_brake_pressure_target' */



  /* Update for Enabled SubSystem: '<S105>/Determine_brake_hold_pressure_target' incorporates:

   *  EnablePort: '<S183>/Enable'

   */

  if (L4_MABX_DW.Determine_brake_hold_pressure_t) {

    /* Update for UnitDelay: '<S183>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_c = L4_MABX_B.If_Then_Else_gj.Switch;



    /* Update for UnitDelay: '<S187>/Unit_Delay' incorporates:

     *  Constant: '<S187>/Constant'

     */

    L4_MABX_DW.Unit_Delay_DSTATE_or = L4_MABX_P.Constant_Value_m3;



    /* Update for UnitDelay: '<S191>/FixPt Unit Delay2' incorporates:

     *  Constant: '<S191>/FixPt Constant'

     */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_je = L4_MABX_P.FixPtConstant_Value_aw;



    /* Update for UnitDelay: '<S191>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_b = L4_MABX_B.If_Then_Else_nz.Switch;



    /* Update for UnitDelay: '<S188>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_oj = L4_MABX_B.DigitalClock_c;

  }



  /* End of Update for SubSystem: '<S105>/Determine_brake_hold_pressure_target' */



  /* Update for Enabled SubSystem: '<S77>/Bendix_2C2_brake_application_pressure_feedback_controller' incorporates:

   *  EnablePort: '<S102>/Enable'

   */

  if (L4_MABX_DW.Bendix_2C2_brake_application_pr) {

    /* Update for UnitDelay: '<S111>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_dc = L4_MABX_B.DigitalClock_j;



    /* Update for UnitDelay: '<S115>/Unit_Delay' incorporates:

     *  Constant: '<S115>/Constant'

     */

    L4_MABX_DW.Unit_Delay_DSTATE_omj = L4_MABX_P.Constant_Value_lo;



    /* Update for UnitDelay: '<S135>/Unit_Delay1' incorporates:

     *  Constant: '<S135>/Constant'

     */

    L4_MABX_DW.Unit_Delay1_DSTATE_b = L4_MABX_P.Constant_Value_olo;



    /* Update for UnitDelay: '<S136>/Unit_Delay' incorporates:

     *  Constant: '<S136>/Constant'

     */

    L4_MABX_DW.Unit_Delay_DSTATE_h4 = L4_MABX_P.Constant_Value_hi;



    /* Update for UnitDelay: '<S140>/FixPt Unit Delay2' incorporates:

     *  Constant: '<S140>/FixPt Constant'

     */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_gm = L4_MABX_P.FixPtConstant_Value_f;



    /* Update for UnitDelay: '<S140>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_g1 = L4_MABX_B.If_Then_Else_bg.Switch;



    /* Update for UnitDelay: '<S135>/Unit_Delay2' */

    L4_MABX_DW.Unit_Delay2_DSTATE_dy = L4_MABX_B.If_Then_Else_ly.Switch;



    /* Update for Enabled SubSystem: '<S112>/Calculate_D_term' */

    L4__Calculate_D_term_Update(&L4_MABX_B.Calculate_D_term,

      &L4_MABX_DW.Calculate_D_term, &L4_MABX_P.Calculate_D_term);



    /* End of Update for SubSystem: '<S112>/Calculate_D_term' */



    /* Update for UnitDelay: '<S110>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_i2 = L4_MABX_B.Add_e;



    /* Update for Enabled SubSystem: '<S112>/Calculate_I_term' */

    L4__Calculate_I_term_Update(&L4_MABX_B.Calculate_I_term,

      &L4_MABX_DW.Calculate_I_term, &L4_MABX_P.Calculate_I_term);



    /* End of Update for SubSystem: '<S112>/Calculate_I_term' */

  }



  /* End of Update for SubSystem: '<S77>/Bendix_2C2_brake_application_pressure_feedback_controller' */



  /* Update for UnitDelay: '<S395>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_cx = L4_MABX_B.LogicalOperator2_f;



  /* Update for UnitDelay: '<S396>/Unit_Delay' incorporates:

   *  Constant: '<S396>/Constant'

   */

  L4_MABX_DW.Unit_Delay_DSTATE_d0 = L4_MABX_P.Constant_Value_c1;



  /* Update for UnitDelay: '<S353>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_e = L4_MABX_B.If_Then_Else_m4.Switch;



  /* Update for UnitDelay: '<S400>/FixPt Unit Delay2' incorporates:

   *  Constant: '<S400>/FixPt Constant'

   */

  L4_MABX_DW.FixPtUnitDelay2_DSTATE_aq = L4_MABX_P.FixPtConstant_Value_jx;



  /* Update for UnitDelay: '<S400>/FixPt Unit Delay1' */

  L4_MABX_DW.FixPtUnitDelay1_DSTATE_h = L4_MABX_B.If_Then_Else_m4.Switch;



  /* Update for UnitDelay: '<S397>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_m = L4_MABX_B.DigitalClock;



  /* Update for UnitDelay: '<S384>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_iy = L4_MABX_B.LogicalOperator1_gm;



  /* Update for UnitDelay: '<S385>/Unit_Delay' incorporates:

   *  Constant: '<S385>/Constant'

   */

  L4_MABX_DW.Unit_Delay_DSTATE_mv = L4_MABX_P.Constant_Value_am;



  /* Update for UnitDelay: '<S351>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_g = L4_MABX_B.If_Then_Else_bf.Switch;



  /* Update for UnitDelay: '<S389>/FixPt Unit Delay2' incorporates:

   *  Constant: '<S389>/FixPt Constant'

   */

  L4_MABX_DW.FixPtUnitDelay2_DSTATE_ip = L4_MABX_P.FixPtConstant_Value_d;



  /* Update for UnitDelay: '<S389>/FixPt Unit Delay1' */

  L4_MABX_DW.FixPtUnitDelay1_DSTATE_hq = L4_MABX_B.If_Then_Else_bf.Switch;



  /* Update for UnitDelay: '<S386>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_b = L4_MABX_B.DigitalClock_b;



  /* Update for UnitDelay: '<S348>/Delay Input1' */

  L4_MABX_DW.DelayInput1_DSTATE[0] = L4_MABX_B.Distance_to_achieve_speed_targe;

  L4_MABX_DW.DelayInput1_DSTATE[1] = L4_MABX_B.Vehicle_speed_target_o;



  /* Update for UnitDelay: '<S366>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_bw = L4_MABX_B.If_Then_Else_og.Switch;



  /* Update for UnitDelay: '<S368>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_ko = L4_MABX_B.LogicalOperator1_ph;



  /* Update for UnitDelay: '<S377>/FixPt Unit Delay2' incorporates:

   *  Constant: '<S377>/FixPt Constant'

   */

  L4_MABX_DW.FixPtUnitDelay2_DSTATE_f = L4_MABX_P.FixPtConstant_Value_g;



  /* Update for UnitDelay: '<S377>/FixPt Unit Delay1' */

  L4_MABX_DW.FixPtUnitDelay1_DSTATE_l = L4_MABX_B.Xnew;



  /* Update for UnitDelay: '<S375>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_p = L4_MABX_B.DigitalClock_f;



  /* Update for UnitDelay: '<S355>/Delay Input1' */

  L4_MABX_DW.DelayInput1_DSTATE_f[0] = L4_MABX_B.Distance_to_achieve_speed_targe;

  L4_MABX_DW.DelayInput1_DSTATE_f[1] = L4_MABX_B.Vehicle_speed_target_o;



  /* Update for UnitDelay: '<S357>/Unit_Delay' incorporates:

   *  Constant: '<S357>/Constant'

   */

  L4_MABX_DW.Unit_Delay_DSTATE_l = L4_MABX_P.Constant_Value_pu;



  /* Update for UnitDelay: '<S361>/FixPt Unit Delay2' incorporates:

   *  Constant: '<S361>/FixPt Constant'

   */

  L4_MABX_DW.FixPtUnitDelay2_DSTATE_c = L4_MABX_P.FixPtConstant_Value_az;



  /* Update for UnitDelay: '<S361>/FixPt Unit Delay1' */

  L4_MABX_DW.FixPtUnitDelay1_DSTATE_ej = L4_MABX_B.If_Then_Else_pz.Switch;



  /* Update for UnitDelay: '<S356>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_1_DSTATE_j =

    L4_MABX_B.If_Then_Else_mm.Vehicle_speed_target;

  L4_MABX_DW.Unit_Delay_2_DSTATE_e = L4_MABX_B.If_Then_Else_mm.Vehicle_speed;

  L4_MABX_DW.Unit_Delay_3_DSTATE_j = L4_MABX_B.If_Then_Else_mm.Distance_m;



  /* Update for UnitDelay: '<S354>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_f = L4_MABX_B.DigitalClock_p;



  /* Update for Enabled SubSystem: '<S77>/Bendix_2C2_vehicle_speed_feedback_pressure_controller' incorporates:

   *  EnablePort: '<S103>/Enable'

   */

  if (L4_MABX_DW.Bendix_2C2_vehicle_speed_feedba) {

    /* Update for UnitDelay: '<S146>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_eu = L4_MABX_B.DigitalClock_n;



    /* Update for UnitDelay: '<S153>/Unit_Delay' incorporates:

     *  Constant: '<S153>/Constant'

     */

    L4_MABX_DW.Unit_Delay_DSTATE_n = L4_MABX_P.Constant_Value_j5;



    /* Update for UnitDelay: '<S173>/Unit_Delay1' incorporates:

     *  Constant: '<S173>/Constant'

     */

    L4_MABX_DW.Unit_Delay1_DSTATE_f = L4_MABX_P.Constant_Value_bd;



    /* Update for UnitDelay: '<S174>/Unit_Delay' incorporates:

     *  Constant: '<S174>/Constant'

     */

    L4_MABX_DW.Unit_Delay_DSTATE_g4 = L4_MABX_P.Constant_Value_m2;



    /* Update for UnitDelay: '<S178>/FixPt Unit Delay2' incorporates:

     *  Constant: '<S178>/FixPt Constant'

     */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_o = L4_MABX_P.FixPtConstant_Value_j1;



    /* Update for UnitDelay: '<S178>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_g2 = L4_MABX_B.If_Then_Else_iy.Switch;



    /* Update for UnitDelay: '<S173>/Unit_Delay2' */

    L4_MABX_DW.Unit_Delay2_DSTATE_c = L4_MABX_B.If_Then_Else_bc.Switch;



    /* Update for Enabled SubSystem: '<S150>/Calculate_D_term' */

    L4__Calculate_D_term_Update(&L4_MABX_B.Calculate_D_term_p,

      &L4_MABX_DW.Calculate_D_term_p, &L4_MABX_P.Calculate_D_term_p);



    /* End of Update for SubSystem: '<S150>/Calculate_D_term' */



    /* Update for UnitDelay: '<S145>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_h = L4_MABX_B.Add_mh;



    /* Update for Enabled SubSystem: '<S150>/Calculate_I_term' */

    L4__Calculate_I_term_Update(&L4_MABX_B.Calculate_I_term_e,

      &L4_MABX_DW.Calculate_I_term_e, &L4_MABX_P.Calculate_I_term_e);



    /* End of Update for SubSystem: '<S150>/Calculate_I_term' */

  }



  /* End of Update for SubSystem: '<S77>/Bendix_2C2_vehicle_speed_feedback_pressure_controller' */



  /* Update for UnitDelay: '<S107>/Unit_Delay' incorporates:

   *  Constant: '<S107>/Constant7'

   */

  L4_MABX_DW.Unit_Delay_DSTATE_eu4 = L4_MABX_P.Constant7_Value_j;



  /* Update for UnitDelay: '<S203>/Unit_Delay1' incorporates:

   *  Constant: '<S203>/Constant'

   */

  L4_MABX_DW.Unit_Delay1_DSTATE_di = L4_MABX_P.Constant_Value_jf;



  /* Update for UnitDelay: '<S203>/Unit_Delay2' */

  L4_MABX_DW.Unit_Delay2_DSTATE_e = L4_MABX_B.If_Then_Else_g.Switch;



  /* Update for UnitDelay: '<S202>/UD' */

  L4_MABX_DW.UD_DSTATE = L4_MABX_B.TSamp;



  /* Update for UnitDelay: '<S333>/Unit_Delay1' incorporates:

   *  Constant: '<S333>/Constant'

   */

  L4_MABX_DW.Unit_Delay1_DSTATE_db = L4_MABX_P.Constant_Value_hx;



  /* Update for UnitDelay: '<S333>/Unit_Delay2' */

  L4_MABX_DW.Unit_Delay2_DSTATE_d = L4_MABX_B.If_Then_Else_b3.Switch;



  /* Update for UnitDelay: '<S332>/Delay Input1' */

  L4_MABX_DW.DelayInput1_DSTATE_f0 = L4_MABX_B.JumpNearEdge;



  /* Update for UnitDelay: '<S334>/Unit_Delay1' incorporates:

   *  Constant: '<S334>/Constant'

   */

  L4_MABX_DW.Unit_Delay1_DSTATE_a = L4_MABX_P.Constant_Value_bh;



  /* Update for UnitDelay: '<S334>/Unit_Delay2' */

  L4_MABX_DW.Unit_Delay2_DSTATE_i = L4_MABX_B.If_Then_Else_mk.Switch;



  /* Update for UnitDelay: '<S335>/Unit_Delay1' incorporates:

   *  Constant: '<S335>/Constant'

   */

  L4_MABX_DW.Unit_Delay1_DSTATE_p3 = L4_MABX_P.Constant_Value_hxo;



  /* Update for UnitDelay: '<S335>/Unit_Delay2' */

  L4_MABX_DW.Unit_Delay2_DSTATE_p = L4_MABX_B.If_Then_Else_lh.Switch;



  /* Update for Enabled SubSystem: '<S283>/Slew_at_event' incorporates:

   *  EnablePort: '<S340>/Enable'

   */

  if (L4_MABX_DW.Slew_at_event_MODE_d) {

    /* Update for UnitDelay: '<S342>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_bd = L4_MABX_B.DataTypeConversion_l1;



    /* Update for UnitDelay: '<S343>/Unit_Delay' incorporates:

     *  Constant: '<S343>/Constant'

     */

    L4_MABX_DW.Unit_Delay_DSTATE_jt = L4_MABX_P.Constant_Value_hgm;



    /* Update for UnitDelay: '<S346>/FixPt Unit Delay2' incorporates:

     *  Constant: '<S346>/FixPt Constant'

     */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_j = L4_MABX_P.FixPtConstant_Value_np;



    /* Update for UnitDelay: '<S346>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_ov = L4_MABX_B.If_Then_Else_n3.Switch;



    /* Update for UnitDelay: '<S341>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_ll = L4_MABX_B.LogicalOperator_dm;

  }



  /* End of Update for SubSystem: '<S283>/Slew_at_event' */



  /* Update for UnitDelay: '<S285>/Unit Delay' */

  L4_MABX_DW.UnitDelay_DSTATE_d = L4_MABX_B.Switch1_fi;



  /* Update for UnitDelay: '<S295>/Unit Delay' */

  L4_MABX_DW.UnitDelay_DSTATE_m = L4_MABX_B.Add1_m;



  /* Update for UnitDelay: '<S296>/Unit Delay' */

  L4_MABX_DW.UnitDelay_DSTATE_m0 = L4_MABX_B.Switch_k;



  /* Update for UnitDelay: '<S296>/Unit Delay1' */

  L4_MABX_DW.UnitDelay1_DSTATE_k = L4_MABX_B.Divide1_b;



  /* Update for UnitDelay: '<S290>/Unit Delay' */

  L4_MABX_DW.UnitDelay_DSTATE_m1 = L4_MABX_B.Switch1_pb;



  /* Update for UnitDelay: '<S314>/Delay Input2' */

  L4_MABX_DW.DelayInput2_DSTATE = L4_MABX_B.DifferenceInputs2;



  /* Update for DiscreteIntegrator: '<S313>/Integrator' */

  L4_MABX_DW.Integrator_DSTATE += L4_MABX_P.Integrator_gainval *

    L4_MABX_B.IntegralGain;

  L4_MABX_DW.Integrator_PrevResetState = (int8_T)L4_MABX_B.AutonomousEnabled_d;



  /* Update for DiscreteIntegrator: '<S313>/Filter' */

  L4_MABX_DW.Filter_DSTATE += L4_MABX_P.Filter_gainval *

    L4_MABX_B.FilterCoefficient;

  L4_MABX_DW.Filter_PrevResetState = (int8_T)L4_MABX_B.AutonomousEnabled_d;



  /* Update for UnitDelay: '<S317>/Delay Input' */

  L4_MABX_DW.DelayInput_DSTATE = L4_MABX_B.Saturate;



  /* Update for UnitDelay: '<S317>/Delay Output' */

  L4_MABX_DW.DelayOutput_DSTATE = L4_MABX_B.Downcast;



  /* Update for UnitDelay: '<S315>/Delay Input2' */

  L4_MABX_DW.DelayInput2_DSTATE_a = L4_MABX_B.DifferenceInputs2_a;



  /* Update for DiscreteIntegrator: '<S307>/Discrete-Time Integrator' */

  L4_MABX_DW.DiscreteTimeIntegrator_IC_LOADI = 0U;

  L4_MABX_DW.DiscreteTimeIntegrator_DSTATE +=

    L4_MABX_P.DiscreteTimeIntegrator_gainval * L4_MABX_B.Gain_o;

  L4_MABX_DW.DiscreteTimeIntegrator_PrevRese = (int8_T)

    L4_MABX_B.AutonomousEnabled_d;



  /* Update for UnitDelay: '<S327>/Delay Input2' */

  L4_MABX_DW.DelayInput2_DSTATE_l = L4_MABX_B.DifferenceInputs2_m;



  /* Update for UnitDelay: '<S304>/Delay Input2' */

  L4_MABX_DW.DelayInput2_DSTATE_o = L4_MABX_B.DifferenceInputs2_f;



  /* Update for DiscreteIntegrator: '<S80>/Discrete-Time Integrator' incorporates:

   *  Constant: '<S80>/ResetIntegrator'

   */

  L4_MABX_DW.DiscreteTimeIntegrator_DSTATE_e +=

    L4_MABX_P.DiscreteTimeIntegrator_gainva_l * L4_MABX_B.Switch1_p;

  if (L4_MABX_DW.DiscreteTimeIntegrator_DSTATE_e >=

      L4_MABX_P.DiscreteTimeIntegrator_UpperSat) {

    L4_MABX_DW.DiscreteTimeIntegrator_DSTATE_e =

      L4_MABX_P.DiscreteTimeIntegrator_UpperSat;

  } else {

    if (L4_MABX_DW.DiscreteTimeIntegrator_DSTATE_e <=

        L4_MABX_P.DiscreteTimeIntegrator_LowerSat) {

      L4_MABX_DW.DiscreteTimeIntegrator_DSTATE_e =

        L4_MABX_P.DiscreteTimeIntegrator_LowerSat;

    }

  }



  if (L4_MABX_P.ResetIntegrator_Value > 0.0) {

    L4_MABX_DW.DiscreteTimeIntegrator_PrevRe_e = 1;

  } else if (L4_MABX_P.ResetIntegrator_Value < 0.0) {

    L4_MABX_DW.DiscreteTimeIntegrator_PrevRe_e = -1;

  } else if (L4_MABX_P.ResetIntegrator_Value == 0.0) {

    L4_MABX_DW.DiscreteTimeIntegrator_PrevRe_e = 0;

  } else {

    L4_MABX_DW.DiscreteTimeIntegrator_PrevRe_e = 2;

  }



  /* End of Update for DiscreteIntegrator: '<S80>/Discrete-Time Integrator' */



  /* Update for UnitDelay: '<S80>/Unit Delay' */

  L4_MABX_DW.UnitDelay_DSTATE_e = L4_MABX_B.Switch2_i1;



  /* Update for UnitDelay: '<S379>/FixPt Unit Delay2' incorporates:

   *  Constant: '<S379>/FixPt Constant'

   */

  L4_MABX_DW.FixPtUnitDelay2_DSTATE_aw = L4_MABX_P.FixPtConstant_Value_p;



  /* Update for UnitDelay: '<S379>/FixPt Unit Delay1' */

  L4_MABX_DW.FixPtUnitDelay1_DSTATE_p = L4_MABX_B.Xnew_h;



  /* Update for UnitDelay: '<S380>/FixPt Unit Delay2' incorporates:

   *  Constant: '<S380>/FixPt Constant'

   */

  L4_MABX_DW.FixPtUnitDelay2_DSTATE_gx = L4_MABX_P.FixPtConstant_Value_e;



  /* Update for UnitDelay: '<S380>/FixPt Unit Delay1' */

  L4_MABX_DW.FixPtUnitDelay1_DSTATE_g0 = L4_MABX_B.Xnew_f;



  /* Update for UnitDelay: '<S374>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_j = L4_MABX_B.DigitalClock_d;



  /* End of Update for SubSystem: '<S65>/Task_10ms' */



  /* Update for Atomic SubSystem: '<S855>/CAN_TX_10ms' */



  /* Update for UnitDelay: '<S1012>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_mr = L4_MABX_B.Operator_k1o;



  /* Update for UnitDelay: '<S1013>/Unit Delay' */

  L4_MABX_DW.UnitDelay_DSTATE_c = L4_MABX_B.Switch1_a;



  /* End of Update for SubSystem: '<S855>/CAN_TX_10ms' */



  /* Update for UnitDelay: '<S865>/Unit Delay2' */

  L4_MABX_DW.UnitDelay2_DSTATE = L4_MABX_B.enTPCM;



  /* Update for UnitDelay: '<S865>/Unit Delay1' */

  L4_MABX_DW.UnitDelay1_DSTATE_mt = L4_MABX_B.TPDT_count;



  /* Update for UnitDelay: '<S865>/Unit Delay3' */

  L4_MABX_DW.UnitDelay3_DSTATE = L4_MABX_B.enTPDT;



  /* Update for UnitDelay: '<S3>/Unit_Delay' incorporates:

   *  Constant: '<S208>/Constant'

   *  Constant: '<S80>/zero'

   */

  L4_MABX_DW.Unit_Delay_1_DSTATE = L4_MABX_B.Subtract_c1;

  L4_MABX_DW.Unit_Delay_10_DSTATE = L4_MABX_B.Add1_hl;

  L4_MABX_DW.Unit_Delay_100_DSTATE = L4_MABX_B.SFunction1_o3_ho;

  L4_MABX_DW.Unit_Delay_101_DSTATE = L4_MABX_B.SPN514_NominalFrictionPercentTo;

  L4_MABX_DW.Unit_Delay_102_DSTATE = L4_MABX_B.SPN2978_EstEngParasiticLossesPe;

  L4_MABX_DW.Unit_Delay_103_DSTATE = L4_MABX_B.SPN1760_GrossCombinationVehicle;

  L4_MABX_DW.Unit_Delay_104_DSTATE = L4_MABX_B.ACCDistanceAlertSignal;

  L4_MABX_DW.Unit_Delay_105_DSTATE = L4_MABX_B.ForwardCollisionWarning;

  L4_MABX_DW.Unit_Delay_106_DSTATE = L4_MABX_B.SPN544_EngineReferenceTorque;

  L4_MABX_DW.Unit_Delay_107_DSTATE = L4_MABX_B.SFunction1_o4_lj;

  L4_MABX_DW.Unit_Delay_108_DSTATE = L4_MABX_B.SFunction1_o5_i;

  L4_MABX_DW.Unit_Delay_109_DSTATE = L4_MABX_B.SFunction1_o6_d;

  L4_MABX_DW.Unit_Delay_11_DSTATE = L4_MABX_B.Switch2_i1;

  L4_MABX_DW.Unit_Delay_110_DSTATE = L4_MABX_B.SFunction1_o7_h;

  L4_MABX_DW.Unit_Delay_111_DSTATE = SteerWheelAngle;

  L4_MABX_DW.Unit_Delay_112_DSTATE = YawRate;

  L4_MABX_DW.Unit_Delay_113_DSTATE = SPN1810_LongitudinalAcceleration;

  L4_MABX_DW.Unit_Delay_114_DSTATE = L4_MABX_B.SFunction1_o2_gn;

  L4_MABX_DW.Unit_Delay_115_DSTATE = L4_MABX_B.SFunction1_o3_jk;

  L4_MABX_DW.Unit_Delay_116_DSTATE = L4_MABX_B.SFunction1_o5_f;

  L4_MABX_DW.Unit_Delay_117_DSTATE = L4_MABX_B.SFunction1_o1_a5;

  L4_MABX_DW.Unit_Delay_118_DSTATE = L4_MABX_B.SFunction1_o3_fp;

  L4_MABX_DW.Unit_Delay_119_DSTATE = L4_MABX_B.LogicalOperator1_c;

  L4_MABX_DW.Unit_Delay_12_DSTATE = L4_MABX_B.DiscreteTimeIntegrator_h;

  L4_MABX_DW.Unit_Delay_120_DSTATE = L4_MABX_B.LogicalOperator1_cl;

  L4_MABX_DW.Unit_Delay_121_DSTATE = L4_MABX_B.PitchAngleExRange;

  L4_MABX_DW.Unit_Delay_122_DSTATE = L4_MABX_B.SFunction1_o3_ev;

  L4_MABX_DW.Unit_Delay_123_DSTATE = L4_MABX_B.SFunction1_o1_oq;

  L4_MABX_DW.Unit_Delay_124_DSTATE = L4_MABX_B.SFunction1_o2_mr;

  L4_MABX_DW.Unit_Delay_125_DSTATE = L4_MABX_B.Latitude_;

  L4_MABX_DW.Unit_Delay_126_DSTATE = L4_MABX_B.Longitude_;

  L4_MABX_DW.Unit_Delay_127_DSTATE = L4_MABX_B.HDOP_;

  L4_MABX_DW.Unit_Delay_128_DSTATE = L4_MABX_B.XPRControlMode;

  L4_MABX_DW.Unit_Delay_129_DSTATE = L4_MABX_B.XPRErrorState;

  L4_MABX_DW.Unit_Delay_13_DSTATE = L4_MABX_B.numLanePoints_j;

  L4_MABX_DW.Unit_Delay_130_DSTATE = L4_MABX_B.PressureP1;

  L4_MABX_DW.Unit_Delay_131_DSTATE = L4_MABX_B.PressureP4;

  L4_MABX_DW.Unit_Delay_132_DSTATE = L4_MABX_B.PressureP21;

  L4_MABX_DW.Unit_Delay_133_DSTATE = L4_MABX_B.PressureP22;

  L4_MABX_DW.Unit_Delay_134_DSTATE = L4_MABX_B.PressureP42;

  L4_MABX_DW.Unit_Delay_135_DSTATE = ReAX_ActualHandwheelPos;

  L4_MABX_DW.Unit_Delay_136_DSTATE = ReAX_EchoedSteerWheelPos;

  L4_MABX_DW.Unit_Delay_137_DSTATE = L4_MABX_B.SystemsOk;

  L4_MABX_DW.Unit_Delay_138_DSTATE = SupervisorMode;

  L4_MABX_DW.Unit_Delay_139_DSTATE = CurrentAzimuth_rad;

  L4_MABX_DW.Unit_Delay_14_DSTATE = L4_MABX_B.correctedError;

  L4_MABX_DW.Unit_Delay_140_DSTATE = TargetAzimuth_rad;

  L4_MABX_DW.Unit_Delay_141_DSTATE = CurrentVelocity_kph;

  L4_MABX_DW.Unit_Delay_142_DSTATE = TargetVelocity_kph;

  L4_MABX_DW.Unit_Delay_143_DSTATE = Curvature;

  L4_MABX_DW.Unit_Delay_144_DSTATE = CrosstrackError;

  L4_MABX_DW.Unit_Delay_15_DSTATE = L4_MABX_B.Switch1_j;

  L4_MABX_DW.Unit_Delay_16_DSTATE = L4_MABX_B.rad2deg1;

  L4_MABX_DW.Unit_Delay_17_DSTATE = L4_MABX_B.If_Then_Else_iz.Switch;

  L4_MABX_DW.Unit_Delay_18_DSTATE = L4_MABX_B.APTC_arb_pedal_low_idl_sw_o;

  L4_MABX_DW.Unit_Delay_19_DSTATE = L4_MABX_B.If_Then_Else_f.Switch;

  L4_MABX_DW.Unit_Delay_2_DSTATE = L4_MABX_B.Add3;

  L4_MABX_DW.Unit_Delay_20_DSTATE = L4_MABX_P.Constant_Value_jg4;

  L4_MABX_DW.Unit_Delay_21_DSTATE = L4_MABX_B.If_Then_Else_pi.Switch;

  L4_MABX_DW.Unit_Delay_22_DSTATE = L4_MABX_B.Add_ds;

  L4_MABX_DW.Unit_Delay_23_DSTATE = L4_MABX_B.If_Then_Else_k2.Switch;

  L4_MABX_DW.Unit_Delay_24_DSTATE = L4_MABX_B.Product_i;

  L4_MABX_DW.Unit_Delay_25_DSTATE = L4_MABX_B.PID_i_term_c;

  L4_MABX_DW.Unit_Delay_26_DSTATE = L4_MABX_B.PID_d_term_c;

  L4_MABX_DW.Unit_Delay_27_DSTATE = L4_MABX_B.PID_hold_i_term_f_b;

  L4_MABX_DW.Unit_Delay_28_DSTATE = L4_MABX_B.ThrottlePID_Y_m;

  L4_MABX_DW.Unit_Delay_29_DSTATE = L4_MABX_B.MinMax1_n;

  L4_MABX_DW.Unit_Delay_3_DSTATE = L4_MABX_B.Add_px;

  L4_MABX_DW.Unit_Delay_30_DSTATE = L4_MABX_B.F_Ignition_relay_command_i;

  L4_MABX_DW.Unit_Delay_31_DSTATE = L4_MABX_B.F_Inverter_relay_command_p;

  L4_MABX_DW.Unit_Delay_32_DSTATE = L4_MABX_B.F_MABX_relay_command_n;

  L4_MABX_DW.Unit_Delay_33_DSTATE = L4_MABX_B.F_Sensor_relay_command_k;

  L4_MABX_DW.Unit_Delay_34_DSTATE = L4_MABX_B.BrkPedArbBrakeSwitch_c;

  L4_MABX_DW.Unit_Delay_35_DSTATE = L4_MABX_B.Diff;

  L4_MABX_DW.Unit_Delay_36_DSTATE = L4_MABX_B.F_Brake_control_active;

  L4_MABX_DW.Unit_Delay_37_DSTATE = L4_MABX_B.F_Hold_brakes_at_zero_d;

  L4_MABX_DW.Unit_Delay_38_DSTATE = L4_MABX_B.BrakingPID_Y_k;

  L4_MABX_DW.Unit_Delay_39_DSTATE = 0.0;

  L4_MABX_DW.Unit_Delay_4_DSTATE = L4_MABX_B.Product_d;

  L4_MABX_DW.Unit_Delay_40_DSTATE = L4_MABX_B.VSPD_TARGET_KPH_APV_g;

  L4_MABX_DW.Unit_Delay_41_DSTATE = L4_MABX_B.Vehicle_speed_target_n;

  L4_MABX_DW.Unit_Delay_42_DSTATE = L4_MABX_B.VSPD_HYST_KPH_APV_f;

  L4_MABX_DW.Unit_Delay_43_DSTATE = L4_MABX_B.VSPD_BRAKE_STOP_THRESH_KPH_AP_b;

  L4_MABX_DW.Unit_Delay_44_DSTATE = L4_MABX_B.ACCEL_LIM_MS2_APV_b;

  L4_MABX_DW.Unit_Delay_46_DSTATE = AutonomousOutputEnabled;

  L4_MABX_DW.Unit_Delay_5_DSTATE = L4_MABX_B.Switch2_i;

  L4_MABX_DW.Unit_Delay_6_DSTATE = L4_MABX_B.Conversion;

  L4_MABX_DW.Unit_Delay_7_DSTATE = L4_MABX_B.Add2;

  L4_MABX_DW.Unit_Delay_8_DSTATE = L4_MABX_P.zero_Value;

  L4_MABX_DW.Unit_Delay_82_DSTATE = EngagePB;

  L4_MABX_DW.Unit_Delay_85_DSTATE = Pedal_pwm_position;

  L4_MABX_DW.Unit_Delay_86_DSTATE = L4_MABX_B.IgnitionKeySwitch_voltage;

  L4_MABX_DW.Unit_Delay_87_DSTATE = L4_MABX_B.SFunction1_o8_fp;

  L4_MABX_DW.Unit_Delay_88_DSTATE = L4_MABX_B.SFunction1_o2_bl;

  L4_MABX_DW.Unit_Delay_89_DSTATE = L4_MABX_B.SFunction1_o7_g;

  L4_MABX_DW.Unit_Delay_9_DSTATE = L4_MABX_B.Add1_hl;

  L4_MABX_DW.Unit_Delay_90_DSTATE = L4_MABX_B.SFunction1_o1_gd;

  L4_MABX_DW.Unit_Delay_91_DSTATE = L4_MABX_B.SFunction1_o1_au;

  L4_MABX_DW.Unit_Delay_92_DSTATE = L4_MABX_B.SFunction1_o2_hu;

  L4_MABX_DW.Unit_Delay_93_DSTATE = L4_MABX_B.SFunction1_o4_nj;

  L4_MABX_DW.Unit_Delay_94_DSTATE = L4_MABX_B.SPN524_TransSelectedGear;

  L4_MABX_DW.Unit_Delay_95_DSTATE = L4_MABX_B.SPN523_TransCurrentGear;

  L4_MABX_DW.Unit_Delay_96_DSTATE = L4_MABX_B.SPN526_TransActualGearRatio;

  L4_MABX_DW.Unit_Delay_97_DSTATE = L4_MABX_B.SFunction1_o4_ki;

  L4_MABX_DW.Unit_Delay_98_DSTATE = L4_MABX_B.SFunction1_o2_dgu;

  L4_MABX_DW.Unit_Delay_99_DSTATE = L4_MABX_B.SFunction1_o5_nl;



  /* Update for UnitDelay: '<S655>/Unit_Delay2' */

  L4_MABX_DW.Unit_Delay2_DSTATE_p1 = L4_MABX_B.LogicalOperator2_j;



  /* Update for UnitDelay: '<S655>/Unit_Delay1' incorporates:

   *  Constant: '<S655>/Constant1'

   */

  L4_MABX_DW.Unit_Delay1_DSTATE_d = L4_MABX_P.Constant1_Value_h;



  /* Update for UnitDelay: '<S662>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_iv = L4_MABX_B.LogicalOperator1_cl;



  /* Update for UnitDelay: '<S753>/Delay Input1' */

  L4_MABX_DW.DelayInput1_DSTATE_l = L4_MABX_B.Compare_ai;



  /* Update for UnitDelay: '<S754>/Unit Delay' */

  L4_MABX_DW.UnitDelay_DSTATE_j = L4_MABX_B.Switch_m;



  /* Update for UnitDelay: '<S748>/Unit Delay' */

  L4_MABX_DW.UnitDelay_DSTATE_cq = L4_MABX_B.AND_j;



  /* Update for UnitDelay: '<S752>/Delay Input1' */

  L4_MABX_DW.DelayInput1_DSTATE_c = L4_MABX_B.Compare_b;



  /* Update for UnitDelay: '<S754>/Unit Delay1' */

  L4_MABX_DW.UnitDelay1_DSTATE_n = L4_MABX_B.AND_d;



  /* Update for UnitDelay: '<S755>/Unit Delay' */

  L4_MABX_DW.UnitDelay_DSTATE_is = L4_MABX_B.Switch_h;



  /* Update for UnitDelay: '<S755>/Unit Delay1' */

  L4_MABX_DW.UnitDelay1_DSTATE_pn = L4_MABX_B.AND_j;



  /* Update for UnitDelay: '<S10>/Unit_Delay' incorporates:

   *  Constant: '<S10>/Constant'

   */

  L4_MABX_DW.Unit_Delay_DSTATE_do = L4_MABX_P.Constant_Value_g5;



  /* Update absolute time */

  /* The "clockTick0" counts the number of times the code of this task has

   * been executed. The absolute time is the multiplication of "clockTick0"

   * and "Timing.stepSize0". Size of "clockTick0" ensures timer will not

   * overflow during the application lifespan selected.

   * Timer of this task consists of two 32 bit unsigned integers.

   * The two integers represent the low bits Timing.clockTick0 and the high bits

   * Timing.clockTickH0. When the low bit overflows to 0, the high bits increment.

   */

  if (!(++L4_MABX_M->Timing.clockTick0)) {

    ++L4_MABX_M->Timing.clockTickH0;

  }



  L4_MABX_M->Timing.t[0] = L4_MABX_M->Timing.clockTick0 *

    L4_MABX_M->Timing.stepSize0 + L4_MABX_M->Timing.clockTickH0 *

    L4_MABX_M->Timing.stepSize0 * 4294967296.0;

}



/* Model output function for TID1 */

void L4_MABX_output1(void)             /* Sample time: [0.02s, 0.0s] */

{

  int_T tid = 1;

  int32_T i;

  uint32_T q0;

  uint32_T qY;

  uint8_T tmp;

  real_T u0;

  real_T u1;

  real_T u2;



  /* Outputs for Atomic SubSystem: '<S855>/CAN_TX_20ms' */



  /* Switch: '<S1021>/Switch1' incorporates:

   *  Constant: '<S1021>/Constant4'

   */

  if (L4_MABX_B.AutonomousOutputEnabled_h) {

    /* Product: '<S1021>/Divide1' incorporates:

     *  Constant: '<S1021>/Constant2'

     */

    L4_MABX_B.XBRExternalAccelDemand_m = L4_MABX_B.BrakingPID_Y_g *

      L4_MABX_P.Constant2_Value_i;

    L4_MABX_B.XBRExternalAccelDemand = L4_MABX_B.XBRExternalAccelDemand_m;

  } else {

    L4_MABX_B.XBRExternalAccelDemand = L4_MABX_P.Constant4_Value_k;

  }



  /* End of Switch: '<S1021>/Switch1' */



  /* MultiPortSwitch: '<S1021>/Multiport Switch' incorporates:

   *  Constant: '<S1021>/Constant10'

   *  Constant: '<S1021>/Constant7'

   *  Constant: '<S1021>/Constant8'

   *  Constant: '<S1021>/Constant9'

   */

  switch ((int32_T)L4_MABX_B.BrakingControlActive_b) {

   case 0:

    L4_MABX_B.XBRPassThroughActive = L4_MABX_P.Constant10_Value_hg;

    break;



   case 1:

    L4_MABX_B.XBRPassThroughActive = L4_MABX_P.Constant7_Value_g;

    break;



   case 2:

    L4_MABX_B.XBRPassThroughActive = L4_MABX_P.Constant8_Value_i;

    break;



   default:

    L4_MABX_B.XBRPassThroughActive = L4_MABX_P.Constant9_Value_f;

    break;

  }



  /* End of MultiPortSwitch: '<S1021>/Multiport Switch' */



  /* Outputs for Atomic SubSystem: '<S1021>/If_Then_Else' */



  /* Constant: '<S1021>/XBRValueOverride' incorporates:

   *  Constant: '<S1021>/XBRControlMode'

   *  Constant: '<S1021>/XBRControlModeOVR'

   *  Constant: '<S1021>/XBREnduranceBrakeIntegrationMode'

   *  Constant: '<S1021>/XBREnduranceBrakeIntegrationModeOVR'

   *  Constant: '<S1021>/XBRExternalAccelDemandOVR'

   *  Constant: '<S1021>/XBRPassThroughActiveOVR'

   *  Constant: '<S1021>/XBRPassThroughEnabled'

   *  Constant: '<S1021>/XBRPassThroughEnabledOVR'

   *  Constant: '<S1021>/XBRPriority'

   *  Constant: '<S1021>/XBRPriorityOVR'

   *  Constant: '<S1021>/XBRUrgency'

   *  Constant: '<S1021>/XBRUrgencyOVR'

   */

  L4_MABX_If_Then_Else_b(L4_MABX_P.XBRValueOverride_Value,

    L4_MABX_P.XBRExternalAccelDemandOVR_Value,

    L4_MABX_P.XBREnduranceBrakeIntegrationMod, L4_MABX_P.XBRPriorityOVR_Value,

    L4_MABX_P.XBRControlModeOVR_Value, L4_MABX_P.XBRPassThroughActiveOVR_Value,

    L4_MABX_P.XBRUrgencyOVR_Value, L4_MABX_P.XBRPassThroughEnabledOVR_Value,

    L4_MABX_B.XBRExternalAccelDemand, L4_MABX_P.XBREnduranceBrakeIntegrationM_f,

    L4_MABX_P.XBRPriority_Value, L4_MABX_P.XBRControlMode_Value,

    L4_MABX_B.XBRPassThroughActive, L4_MABX_P.XBRUrgency_Value,

    L4_MABX_P.XBRPassThroughEnabled_Value, &L4_MABX_B.If_Then_Else_b2);



  /* End of Outputs for SubSystem: '<S1021>/If_Then_Else' */



  /* DataTypeConversion: '<S1024>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_a = (real_T)

    L4_MABX_B.If_Then_Else_b2.XBREnduranceBrakeIntegrationMod;



  /* DataTypeConversion: '<S1024>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_bk = (real_T)

    L4_MABX_B.If_Then_Else_b2.XBRPriority;



  /* DataTypeConversion: '<S1024>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_n = (real_T)

    L4_MABX_B.If_Then_Else_b2.XBRControlMode;



  /* DataTypeConversion: '<S1024>/Data Type Conversion4' */

  L4_MABX_B.DataTypeConversion4_i =

    L4_MABX_B.If_Then_Else_b2.XBRExternalAccelDemand;



  /* DataTypeConversion: '<S1024>/Data Type Conversion5' */

  L4_MABX_B.DataTypeConversion5_g = (real_T)

    L4_MABX_B.If_Then_Else_b2.XBRPassThroughActive;



  /* DataTypeConversion: '<S1024>/Data Type Conversion6' */

  L4_MABX_B.DataTypeConversion6_p = L4_MABX_B.If_Then_Else_b2.XBRUrgency;



  /* DataTypeConversion: '<S1024>/Data Type Conversion7' */

  L4_MABX_B.DataTypeConversion7_li =

    L4_MABX_B.If_Then_Else_b2.XBRPassThroughEnabled;



  /* UnitDelay: '<S1017>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_g = L4_MABX_DW.Unit_Delay_DSTATE_j5;



  /* Logic: '<S1017>/Logical Operator8' */

  L4_MABX_B.LogicalOperator8_i = !L4_MABX_B.TmpRTBAtLogicalOperator8Inport1;



  /* Logic: '<S1017>/Logical Operator7' */

  L4_MABX_B.LogicalOperator7_h = (L4_MABX_B.Unit_Delay_g &&

    L4_MABX_B.LogicalOperator8_i);



  /* Logic: '<S1017>/Logical Operator1' */

  L4_MABX_B.LogicalOperator1_ct = (L4_MABX_B.LogicalOperator7_h ||

    L4_MABX_B.TmpRTBAtLogicalOperator1Inport2);



  /* DataTypeConversion: '<S1017>/Data Type Conversion' incorporates:

   *  Constant: '<S861>/CANT_PROPB_XBR_B3_CHANNEL_APV'

   */

  u0 = L4_MABX_P.CANT_PROPB_XBR_B3_CHANNEL_APV_V;

  if (u0 < 256.0) {

    if (u0 >= 0.0) {

      tmp = (uint8_T)u0;

    } else {

      tmp = 0U;

    }

  } else {

    tmp = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion_d0 = tmp;



  /* End of DataTypeConversion: '<S1017>/Data Type Conversion' */



  /* S-Function (sfix_bitop): '<S1022>/Operator' */

  L4_MABX_B.Operator_ny = (uint8_T)(L4_MABX_B.DataTypeConversion_d0 &

    L4_MABX_P.Operator_BitMask_go);



  /* DataTypeConversion: '<S1022>/DataType' */

  L4_MABX_B.DataType_fq = L4_MABX_B.Operator_ny;



  /* DataTypeConversion: '<S1017>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_lv = (L4_MABX_B.DataType_fq != 0);



  /* Logic: '<S1017>/Logical Operator' */

  L4_MABX_B.LogicalOperator_ga = (L4_MABX_B.LogicalOperator1_ct &&

    L4_MABX_B.DataTypeConversion2_lv);



  /* Outputs for Enabled SubSystem: '<S1024>/PropB_XBR_B3' incorporates:

   *  EnablePort: '<S1025>/Enable'

   */

  if (L4_MABX_B.LogicalOperator_ga) {

    /* S-Function (rti_commonblock): '<S1025>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "PropB_XBR_B3" Id:218038707 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF01B3]);



      /* Convert timestamp */

      if (can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF01B3]->processed) {

        can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF01B3]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF01B3]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF01B3]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_jl = (real_T)

          can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF01B3]->processed;

        L4_MABX_B.SFunction1_o2_ph = (real_T)

          can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF01B3]->timestamp;

        L4_MABX_B.SFunction1_o3_b = (real_T)

          can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF01B3]->deltatime;

        L4_MABX_B.SFunction1_o4_g = (real_T)

          can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF01B3]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "SPN2920_ExternalAccelerationDemand" (0|16, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion4_i -

          ( -15.687 ) ) / 0.00048828125 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte1;



        /* ...... "SPN2915_XBREnduranceBrkIntegrationMode" (16|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_a ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN2915_XBRPriority" (18|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion2_bk ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN2916_XBRControlMode" (20|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion3_n ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "XBRPassThroughActive" (22|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion5_g ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN4099_XBRUrgency" (24|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion6_p - ( 0 )

          ) / 0.4 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "XBRPassThroughEnable" (54|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion7_li ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;

      }



      /* mask unused bits with '1' */

      CAN_Msg[4] |= 0xFF;

      CAN_Msg[5] |= 0xFF;

      CAN_Msg[6] |= 0x3F;

      CAN_Msg[7] |= 0xFF;



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF01B3], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  /* End of Outputs for SubSystem: '<S1024>/PropB_XBR_B3' */



  /* RelationalOperator: '<S1023>/Compare' incorporates:

   *  Constant: '<S1023>/Constant'

   */

  L4_MABX_B.Compare_it = (L4_MABX_B.If_Then_Else_b2.XBRPassThroughActive ==

    L4_MABX_P.CompareToConstant_const_ee);



  /* Saturate: '<S1020>/Saturation' incorporates:

   *  Constant: '<S1020>/2C2_OR_VALUE_APV'

   */

  u0 = L4_MABX_P.uC2_OR_VALUE_APV_Value;

  u1 = L4_MABX_P.Saturation_LowerSat_n;

  u2 = L4_MABX_P.Saturation_UpperSat_fc;

  if (u0 > u2) {

    L4_MABX_B.Saturation_n = u2;

  } else if (u0 < u1) {

    L4_MABX_B.Saturation_n = u1;

  } else {

    L4_MABX_B.Saturation_n = u0;

  }



  /* End of Saturate: '<S1020>/Saturation' */



  /* Outputs for Atomic SubSystem: '<S1020>/If_Then_Else1' */



  /* Constant: '<S1020>/F_2C2_OR_APV' */

  L4_MABX_If_Then_Else_g(L4_MABX_P.F_2C2_OR_APV_Value, L4_MABX_B.Saturation_n,

    L4_MABX_B.BrakingPID_Y_gc, &L4_MABX_B.If_Then_Else1_j);



  /* End of Outputs for SubSystem: '<S1020>/If_Then_Else1' */



  /* Gain: '<S1020>/Gain' */

  L4_MABX_B.Gain_d = L4_MABX_P.Gain_Gain_pd * L4_MABX_B.If_Then_Else1_j.Switch;



  /* Gain: '<S1037>/Gain' */

  L4_MABX_B.Gain_b = L4_MABX_P.Gain_Gain_gn * L4_MABX_B.Gain_d;



  /* DataTypeConversion: '<S1037>/Data Type Conversion2' */

  u0 = floor(L4_MABX_B.Gain_b);

  if (rtIsNaN(u0) || rtIsInf(u0)) {

    u0 = 0.0;

  } else {

    u0 = fmod(u0, 256.0);

  }



  L4_MABX_B.DataTypeConversion2_ki = (uint8_T)(u0 < 0.0 ? (int32_T)(uint8_T)

    -(int8_T)(uint8_T)-u0 : (int32_T)(uint8_T)u0);



  /* End of DataTypeConversion: '<S1037>/Data Type Conversion2' */



  /* DataTypeConversion: '<S1037>/Data Type Conversion3' incorporates:

   *  Constant: '<S1020>/BrkControlMode_Active'

   */

  u0 = floor(L4_MABX_P.BrkControlMode_Active_Value);

  if (rtIsNaN(u0) || rtIsInf(u0)) {

    u0 = 0.0;

  } else {

    u0 = fmod(u0, 256.0);

  }



  L4_MABX_B.DataTypeConversion3_imv = (uint8_T)(u0 < 0.0 ? (int32_T)(uint8_T)

    -(int8_T)(uint8_T)-u0 : (int32_T)(uint8_T)u0);



  /* End of DataTypeConversion: '<S1037>/Data Type Conversion3' */



  /* S-Function (sfix_bitop): '<S1037>/Bitwise Operator14' */

  L4_MABX_B.BitwiseOperator14 = (uint8_T)(L4_MABX_B.DataTypeConversion3_imv &

    L4_MABX_P.BitwiseOperator14_BitMask);



  /* DataTypeConversion: '<S1037>/Data Type Conversion4' incorporates:

   *  Constant: '<S1020>/BrkControlPriority'

   */

  u0 = floor(L4_MABX_P.BrkControlPriority_Value);

  if (rtIsNaN(u0) || rtIsInf(u0)) {

    u0 = 0.0;

  } else {

    u0 = fmod(u0, 256.0);

  }



  L4_MABX_B.DataTypeConversion4_m = (uint8_T)(u0 < 0.0 ? (int32_T)(uint8_T)

    -(int8_T)(uint8_T)-u0 : (int32_T)(uint8_T)u0);



  /* End of DataTypeConversion: '<S1037>/Data Type Conversion4' */



  /* S-Function (sfix_bitop): '<S1037>/Bitwise Operator1' */

  L4_MABX_B.BitwiseOperator1 = (uint8_T)(L4_MABX_B.DataTypeConversion4_m &

    L4_MABX_P.BitwiseOperator1_BitMask);



  /* ArithShift: '<S1037>/Shift_Arithmetic ' */

  L4_MABX_B.Shift_Arithmetic_ckw = (uint8_T)(L4_MABX_B.BitwiseOperator1 << 2);



  /* DataTypeConversion: '<S1037>/Data Type Conversion12' */

  L4_MABX_B.DataTypeConversion12_p = L4_MABX_B.Shift_Arithmetic_ckw;



  /* DataTypeConversion: '<S1037>/Data Type Conversion6' incorporates:

   *  Constant: '<S1037>/Constant2'

   */

  L4_MABX_B.DataTypeConversion6_dw = L4_MABX_P.Constant2_Value_al;



  /* S-Function (sfix_bitop): '<S1037>/Bitwise Operator17' */

  L4_MABX_B.BitwiseOperator17_c = (uint8_T)(L4_MABX_B.BitwiseOperator14 |

    L4_MABX_B.DataTypeConversion12_p | L4_MABX_B.DataTypeConversion6_dw);



  /* Gain: '<S1037>/Gain1' incorporates:

   *  Constant: '<S1020>/BrkControl_RearAxlePressureProportioning'

   */

  L4_MABX_B.Gain1_p = L4_MABX_P.Gain1_Gain_d *

    L4_MABX_P.BrkControl_RearAxlePressureProp;



  /* DataTypeConversion: '<S1037>/Data Type Conversion11' */

  u0 = floor(L4_MABX_B.Gain1_p);

  if (rtIsNaN(u0) || rtIsInf(u0)) {

    u0 = 0.0;

  } else {

    u0 = fmod(u0, 256.0);

  }



  L4_MABX_B.DataTypeConversion11_os = (uint8_T)(u0 < 0.0 ? (int32_T)(uint8_T)

    -(int8_T)(uint8_T)-u0 : (int32_T)(uint8_T)u0);



  /* End of DataTypeConversion: '<S1037>/Data Type Conversion11' */



  /* Reshape: '<S1040>/Reshape' incorporates:

   *  Constant: '<S1040>/Constant'

   */

  for (i = 0; i < 16; i++) {

    L4_MABX_B.Reshape_i[i] = L4_MABX_P.Repeating_Sequence_Stair_Out_lc[i];

  }



  /* End of Reshape: '<S1040>/Reshape' */



  /* UnitDelay: '<S1040>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_iy = L4_MABX_DW.Unit_Delay_DSTATE_f3;



  /* UnitDelay: '<S1041>/Unit Delay' */

  L4_MABX_B.UnitDelay_iw = L4_MABX_DW.UnitDelay_DSTATE_em;



  /* Switch: '<S1044>/Switch1' incorporates:

   *  Constant: '<S1041>/E'

   *  Constant: '<S1041>/IV'

   *  Switch: '<S1043>/Switch1'

   */

  if (L4_MABX_B.Unit_Delay_iy) {

    L4_MABX_B.Switch1_pk = L4_MABX_P.IV_Value_h3;

  } else {

    if (L4_MABX_P.E_Value_mg) {

      /* Sum: '<S1041>/Subtract' incorporates:

       *  Constant: '<S1041>/Constant'

       *  Switch: '<S1043>/Switch1'

       */

      q0 = L4_MABX_P.Constant_Value_hp;

      qY = q0 + L4_MABX_B.UnitDelay_iw;

      if (qY < q0) {

        qY = MAX_uint32_T;

      }



      L4_MABX_B.Subtract_lm = qY;



      /* End of Sum: '<S1041>/Subtract' */



      /* Switch: '<S1043>/Switch1' */

      L4_MABX_B.Switch1_e = L4_MABX_B.Subtract_lm;

    } else {

      /* Switch: '<S1043>/Switch1' */

      L4_MABX_B.Switch1_e = L4_MABX_B.UnitDelay_iw;

    }



    L4_MABX_B.Switch1_pk = L4_MABX_B.Switch1_e;

  }



  /* End of Switch: '<S1044>/Switch1' */



  /* Selector: '<S1040>/Selector' */

  L4_MABX_B.Selector_l = L4_MABX_B.Reshape_i[(int32_T)L4_MABX_B.Switch1_pk - 1];



  /* DataTypeConversion: '<S1037>/Data Type Conversion10' */

  L4_MABX_B.DataTypeConversion10_a = L4_MABX_B.Selector_l;



  /* S-Function (sfix_bitop): '<S1037>/Bitwise Operator6' */

  L4_MABX_B.BitwiseOperator6 = (uint8_T)(L4_MABX_B.DataTypeConversion10_a &

    L4_MABX_P.BitwiseOperator6_BitMask);



  /* DataTypeConversion: '<S1036>/Data Type Conversion6' incorporates:

   *  Constant: '<S1036>/Priority'

   */

  L4_MABX_B.DataTypeConversion6_n = L4_MABX_P.Priority_Value_e;



  /* ArithShift: '<S1036>/Shift_Arithmetic 5' */

  L4_MABX_B.Shift_Arithmetic5 = L4_MABX_B.DataTypeConversion6_n << 26;



  /* DataTypeConversion: '<S1036>/Data Type Conversion7' incorporates:

   *  Constant: '<S1036>/ExtendedDataPage'

   */

  L4_MABX_B.DataTypeConversion7_i = L4_MABX_P.ExtendedDataPage_Value_m;



  /* ArithShift: '<S1036>/Shift_Arithmetic 6' */

  L4_MABX_B.Shift_Arithmetic6 = L4_MABX_B.DataTypeConversion7_i << 25;



  /* DataTypeConversion: '<S1036>/Data Type Conversion8' incorporates:

   *  Constant: '<S1036>/DataPage'

   */

  L4_MABX_B.DataTypeConversion8_o = L4_MABX_P.DataPage_Value_a;



  /* ArithShift: '<S1036>/Shift_Arithmetic 7' */

  L4_MABX_B.Shift_Arithmetic7 = L4_MABX_B.DataTypeConversion8_o << 24;



  /* DataTypeConversion: '<S1036>/Data Type Conversion9' incorporates:

   *  Constant: '<S1036>/PDUFormat'

   */

  L4_MABX_B.DataTypeConversion9_l = L4_MABX_P.PDUFormat_Value_m;



  /* ArithShift: '<S1036>/Shift_Arithmetic 8' */

  L4_MABX_B.Shift_Arithmetic8 = L4_MABX_B.DataTypeConversion9_l << 16;



  /* DataTypeConversion: '<S1036>/Data Type Conversion10' incorporates:

   *  Constant: '<S1036>/PDUSpecific'

   */

  L4_MABX_B.DataTypeConversion10_f = L4_MABX_P.PDUSpecific_Value_f;



  /* ArithShift: '<S1036>/Shift_Arithmetic 9' */

  L4_MABX_B.Shift_Arithmetic9 = L4_MABX_B.DataTypeConversion10_f << 8;



  /* DataTypeConversion: '<S1036>/Data Type Conversion11' incorporates:

   *  Constant: '<S1036>/SourceAddress'

   */

  L4_MABX_B.DataTypeConversion11_o = L4_MABX_P.SourceAddress_Value_d;



  /* S-Function (sfix_bitop): '<S1036>/Bitwise Operator17' */

  L4_MABX_B.BitwiseOperator17 = L4_MABX_B.Shift_Arithmetic5 |

    L4_MABX_B.Shift_Arithmetic6 | L4_MABX_B.Shift_Arithmetic7 |

    L4_MABX_B.Shift_Arithmetic8 | L4_MABX_B.Shift_Arithmetic9 |

    L4_MABX_B.DataTypeConversion11_o;



  /* DataTypeConversion: '<S1037>/Data Type Conversion7' */

  L4_MABX_B.DataTypeConversion7_eu = L4_MABX_B.BitwiseOperator17;



  /* S-Function (sfix_bitop): '<S1037>/Bitwise Operator2' */

  L4_MABX_B.BitwiseOperator2 = L4_MABX_B.DataTypeConversion7_eu &

    L4_MABX_P.BitwiseOperator2_BitMask;



  /* S-Function (sfix_bitop): '<S1037>/Bitwise Operator3' */

  L4_MABX_B.BitwiseOperator3 = L4_MABX_B.DataTypeConversion7_eu &

    L4_MABX_P.BitwiseOperator3_BitMask;



  /* ArithShift: '<S1037>/Shift_Arithmetic 3' */

  L4_MABX_B.Shift_Arithmetic3_g = L4_MABX_B.BitwiseOperator3 >> 8;



  /* DataTypeConversion: '<S1037>/Data Type Conversion5' */

  L4_MABX_B.DataTypeConversion5_gj = (uint8_T)L4_MABX_B.Shift_Arithmetic3_g;



  /* S-Function (sfix_bitop): '<S1037>/Bitwise Operator4' */

  L4_MABX_B.BitwiseOperator4 = L4_MABX_B.DataTypeConversion7_eu &

    L4_MABX_P.BitwiseOperator4_BitMask;



  /* ArithShift: '<S1037>/Shift_Arithmetic 4' */

  L4_MABX_B.Shift_Arithmetic4_g = L4_MABX_B.BitwiseOperator4 >> 16;



  /* DataTypeConversion: '<S1037>/Data Type Conversion8' */

  L4_MABX_B.DataTypeConversion8_i = (uint8_T)L4_MABX_B.Shift_Arithmetic4_g;



  /* S-Function (sfix_bitop): '<S1037>/Bitwise Operator5' */

  L4_MABX_B.BitwiseOperator5 = L4_MABX_B.DataTypeConversion7_eu &

    L4_MABX_P.BitwiseOperator5_BitMask;



  /* ArithShift: '<S1037>/Shift_Arithmetic 5' */

  L4_MABX_B.Shift_Arithmetic5_b = L4_MABX_B.BitwiseOperator5 >> 24;



  /* DataTypeConversion: '<S1037>/Data Type Conversion9' */

  L4_MABX_B.DataTypeConversion9_m = (uint8_T)L4_MABX_B.Shift_Arithmetic5_b;



  /* Sum: '<S1037>/Add2' incorporates:

   *  Constant: '<S1037>/Constant'

   *  Constant: '<S1037>/Constant1'

   *  Constant: '<S1037>/Constant3'

   *  Constant: '<S1037>/Constant4'

   */

  L4_MABX_B.Add2_d = (uint8_T)((uint32_T)(uint8_T)((uint32_T)(uint8_T)((uint32_T)

    (uint8_T)((uint32_T)(uint8_T)((uint32_T)(uint8_T)((uint32_T)(uint8_T)

    ((uint32_T)(uint8_T)((uint32_T)(uint8_T)((uint32_T)(uint8_T)((uint32_T)

    (uint8_T)((uint32_T)L4_MABX_B.DataTypeConversion2_ki +

              L4_MABX_B.BitwiseOperator17_c) + L4_MABX_B.DataTypeConversion11_os)

    + L4_MABX_P.Constant3_Value_a) + L4_MABX_P.Constant4_Value_c3) +

     L4_MABX_P.Constant_Value_ls) + L4_MABX_P.Constant1_Value_k) + (uint8_T)

    L4_MABX_B.BitwiseOperator2) + L4_MABX_B.DataTypeConversion5_gj) +

    L4_MABX_B.DataTypeConversion8_i) + L4_MABX_B.DataTypeConversion9_m) +

    L4_MABX_B.BitwiseOperator6);



  /* ArithShift: '<S1037>/Shift_Arithmetic 6' */

  L4_MABX_B.Shift_Arithmetic6_m = (uint8_T)((uint32_T)L4_MABX_B.Add2_d >> 4);



  /* Sum: '<S1037>/Add3' */

  L4_MABX_B.Add3_n = (uint8_T)((uint32_T)L4_MABX_B.Shift_Arithmetic6_m +

    L4_MABX_B.Add2_d);



  /* S-Function (sfix_bitop): '<S1037>/Bitwise Operator8' */

  L4_MABX_B.BitwiseOperator8 = (uint8_T)(L4_MABX_B.Add3_n &

    L4_MABX_P.BitwiseOperator8_BitMask);



  /* ArithShift: '<S1037>/Shift_Arithmetic 7' */

  L4_MABX_B.Shift_Arithmetic7_k = (uint8_T)(L4_MABX_B.BitwiseOperator8 << 4);



  /* S-Function (sfix_bitop): '<S1037>/Bitwise Operator7' */

  L4_MABX_B.BitwiseOperator7 = (uint8_T)(L4_MABX_B.BitwiseOperator6 |

    L4_MABX_B.Shift_Arithmetic7_k);



  /* DataTypeConversion: '<S1018>/Data Type Conversion1' incorporates:

   *  Constant: '<S1037>/Constant'

   *  Constant: '<S1037>/Constant1'

   *  Constant: '<S1037>/Constant3'

   *  Constant: '<S1037>/Constant4'

   */

  L4_MABX_B.DataTypeConversion1_o[0] = L4_MABX_B.DataTypeConversion2_ki;

  L4_MABX_B.DataTypeConversion1_o[1] = L4_MABX_B.BitwiseOperator17_c;

  L4_MABX_B.DataTypeConversion1_o[2] = L4_MABX_B.DataTypeConversion11_os;

  L4_MABX_B.DataTypeConversion1_o[3] = L4_MABX_P.Constant3_Value_a;

  L4_MABX_B.DataTypeConversion1_o[4] = L4_MABX_P.Constant4_Value_c3;

  L4_MABX_B.DataTypeConversion1_o[5] = L4_MABX_P.Constant_Value_ls;

  L4_MABX_B.DataTypeConversion1_o[6] = L4_MABX_P.Constant1_Value_k;

  L4_MABX_B.DataTypeConversion1_o[7] = L4_MABX_B.BitwiseOperator7;



  /* Outputs for Enabled SubSystem: '<S1026>/PropB_Bendix_2C2_XPR' incorporates:

   *  EnablePort: '<S1027>/Enable'

   */

  /* Constant: '<S1020>/CPV' */

  if (L4_MABX_P.CPV_Value_lq) {

    /* S-Function (rti_commonblock): '<S1027>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "PropB_Bendix_2C2_XPR" Id:218060389 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF5665]);



      /* Convert timestamp */

      if (can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF5665]->processed) {

        can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF5665]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF5665]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF5665]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_e = (real_T)

          can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF5665]->processed;

        L4_MABX_B.SFunction1_o2_g = (real_T)

          can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF5665]->timestamp;

        L4_MABX_B.SFunction1_o3_d = (real_T)

          can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF5665]->deltatime;

        L4_MABX_B.SFunction1_o4_fw = (real_T)

          can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF5665]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "byte1" (0|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_o[0] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte2" (8|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_o[1] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte3" (16|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_o[2] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte4" (24|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_o[3] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte5" (32|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_o[4] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte6" (40|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_o[5] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte7" (48|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_o[6] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte8" (56|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_o[7] ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;

      }



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF5665], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  /* End of Constant: '<S1020>/CPV' */

  /* End of Outputs for SubSystem: '<S1026>/PropB_Bendix_2C2_XPR' */



  /* DataTypeConversion: '<S1034>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_lb = L4_MABX_B.FrontAxleSpeed_b;



  /* DataTypeConversion: '<S1034>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_l = L4_MABX_B.SPN1807_SteeringWheelAngle_g;



  /* DataTypeConversion: '<S1034>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_k = L4_MABX_B.SPN1808_YawRate_i;



  /* DataTypeConversion: '<S1034>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_j = L4_MABX_B.SPN1810_LongitudinalAccelerat_i;



  /* DataTypeConversion: '<S1019>/Data Type Conversion' incorporates:

   *  Constant: '<S861>/CANT_STD_ODOMETRY_CHANNEL_APV'

   */

  L4_MABX_B.DataTypeConversion_p3 = (uint8_T)

    L4_MABX_P.CANT_STD_ODOMETRY_CHANNEL_APV_V;



  /* S-Function (sfix_bitop): '<S1033>/Operator' */

  L4_MABX_B.Operator_pf = (uint8_T)(L4_MABX_B.DataTypeConversion_p3 &

    L4_MABX_P.Operator_BitMask_ej);



  /* DataTypeConversion: '<S1033>/DataType' */

  L4_MABX_B.DataType = L4_MABX_B.Operator_pf;



  /* ArithShift: '<S1019>/Shift_Arithmetic 4' */

  L4_MABX_B.Shift_Arithmetic4 = ldexp(L4_MABX_B.DataType, (-5));



  /* DataTypeConversion: '<S1019>/Data Type Conversion7' */

  L4_MABX_B.DataTypeConversion7_hf = (L4_MABX_B.Shift_Arithmetic4 != 0.0);



  /* Outputs for Enabled SubSystem: '<S1034>/Std_OdometryData' incorporates:

   *  EnablePort: '<S1035>/Enable'

   */

  if (L4_MABX_B.DataTypeConversion7_hf) {

    /* S-Function (rti_commonblock): '<S1035>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "Std_OdometryData" Id:10 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0XA]);



      /* Convert timestamp */

      if (can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0XA]->processed) {

        can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0XA]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0XA]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0XA]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_b = (real_T)

          can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0XA]->processed;

        L4_MABX_B.SFunction1_o2_f = (real_T)

          can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0XA]->timestamp;

        L4_MABX_B.SFunction1_o3_ed = (real_T)

          can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0XA]->deltatime;

        L4_MABX_B.SFunction1_o4_fk = (real_T)

          can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0XA]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "SPN904_FrontAxleSpeed" (0|16, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion_lb - ( 0 )

          ) / 0.00390625 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte1;



        /* ...... "SPN1807_SteeringWheelAngle" (16|16, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_l -

          ( -31.374 ) ) / 0.0009765625 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte1;



        /* ...... "SPN1808_YawRate" (32|16, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion2_k -

          ( -3.92 ) ) / 0.0001220703125 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte1;



        /* ...... "SPN1810_LongitudinalAcceleration" (48|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion3_j -

          ( -12.5 ) ) / 0.1 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;

      }



      /* mask unused bits with '1' */

      CAN_Msg[7] |= 0xFF;



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0XA], 8, &(CAN_Msg[0]),

                       delayTime);

    }

  }



  /* End of Outputs for SubSystem: '<S1034>/Std_OdometryData' */



  /* S-Function (sfix_bitop): '<S1028>/Operator' */

  L4_MABX_B.Operator_b1 = (uint8_T)(L4_MABX_B.DataTypeConversion_p3 &

    L4_MABX_P.Operator_BitMask_iv);



  /* DataTypeConversion: '<S1028>/DataType' */

  L4_MABX_B.DataType_jh = L4_MABX_B.Operator_b1;



  /* S-Function (sfix_bitop): '<S1029>/Operator' */

  L4_MABX_B.Operator_du = (uint8_T)(L4_MABX_B.DataTypeConversion_p3 &

    L4_MABX_P.Operator_BitMask_a5);



  /* DataTypeConversion: '<S1029>/DataType' */

  L4_MABX_B.DataType_e = L4_MABX_B.Operator_du;



  /* S-Function (sfix_bitop): '<S1030>/Operator' */

  L4_MABX_B.Operator_eal = (uint8_T)(L4_MABX_B.DataTypeConversion_p3 &

    L4_MABX_P.Operator_BitMask_cl0);



  /* DataTypeConversion: '<S1030>/DataType' */

  L4_MABX_B.DataType_i = L4_MABX_B.Operator_eal;



  /* S-Function (sfix_bitop): '<S1031>/Operator' */

  L4_MABX_B.Operator_mi = (uint8_T)(L4_MABX_B.DataTypeConversion_p3 &

    L4_MABX_P.Operator_BitMask_bv);



  /* DataTypeConversion: '<S1031>/DataType' */

  L4_MABX_B.DataType_b = L4_MABX_B.Operator_mi;



  /* S-Function (sfix_bitop): '<S1032>/Operator' */

  L4_MABX_B.Operator_lh = (uint8_T)(L4_MABX_B.DataTypeConversion_p3 &

    L4_MABX_P.Operator_BitMask_jn);



  /* DataTypeConversion: '<S1032>/DataType' */

  L4_MABX_B.DataType_l = L4_MABX_B.Operator_lh;



  /* DataTypeConversion: '<S1019>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_a3 = (L4_MABX_B.DataType_jh != 0);



  /* ArithShift: '<S1019>/Shift_Arithmetic ' */

  L4_MABX_B.Shift_Arithmetic = ldexp(L4_MABX_B.DataType_e, (-1));



  /* DataTypeConversion: '<S1019>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_pb = (L4_MABX_B.Shift_Arithmetic != 0.0);



  /* ArithShift: '<S1019>/Shift_Arithmetic 1' */

  L4_MABX_B.Shift_Arithmetic1 = ldexp(L4_MABX_B.DataType_i, (-2));



  /* DataTypeConversion: '<S1019>/Data Type Conversion4' */

  L4_MABX_B.DataTypeConversion4_p = (L4_MABX_B.Shift_Arithmetic1 != 0.0);



  /* ArithShift: '<S1019>/Shift_Arithmetic 2' */

  L4_MABX_B.Shift_Arithmetic2 = ldexp(L4_MABX_B.DataType_b, (-3));



  /* DataTypeConversion: '<S1019>/Data Type Conversion5' */

  L4_MABX_B.DataTypeConversion5_pu = (L4_MABX_B.Shift_Arithmetic2 != 0.0);



  /* ArithShift: '<S1019>/Shift_Arithmetic 3' */

  L4_MABX_B.Shift_Arithmetic3 = ldexp(L4_MABX_B.DataType_l, (-4));



  /* DataTypeConversion: '<S1019>/Data Type Conversion6' */

  L4_MABX_B.DataTypeConversion6_bk = (L4_MABX_B.Shift_Arithmetic3 != 0.0);



  /* RelationalOperator: '<S1042>/Operator' */

  L4_MABX_B.Operator_ao = (L4_MABX_B.Switch1_pk == L4_MABX_B.Width_h);



  /* Lookup_n-D: '<S1021>/DECEL_GOV_XBR_URGENCY_MPV' */

  L4_MABX_B.XBRUrgency = look1_binlcapw(L4_MABX_B.XBRExternalAccelDemand,

    L4_MABX_P.DECEL_GOV_XBR_URGENCY_MPV_bp01D,

    L4_MABX_P.DECEL_GOV_XBR_URGENCY_MPV_table, 7U);



  /* End of Outputs for SubSystem: '<S855>/CAN_TX_20ms' */



  /* Outputs for Atomic SubSystem: '<S65>/Task_20ms' */

  /* RelationalOperator: '<S401>/CheckHDOP' incorporates:

   *  Constant: '<S401>/MaximumGoodHDOP'

   */

  L4_MABX_B.CheckHDOP = (L4_MABX_B.HDOP__f <= L4_MABX_P.MaximumGoodHDOP_Value);



  /* Gain: '<S401>/kph2mps' */

  L4_MABX_B.kph2mps = L4_MABX_P.kph2mps_Gain_l * L4_MABX_B.FrontAxleSpeed_d;



  /* Product: '<S401>/Product' incorporates:

   *  Constant: '<S401>/lookAheadTime'

   */

  L4_MABX_B.Product_c = L4_MABX_B.kph2mps * L4_MABX_P.lookAheadTime_Value;



  /* Gain: '<S401>/kph2mps1' */

  L4_MABX_B.kph2mps1 = L4_MABX_P.kph2mps1_Gain * L4_MABX_B.FrontAxleSpeed_dv;



  /* Product: '<S401>/Product1' incorporates:

   *  Constant: '<S401>/lookAheadTime1'

   */

  L4_MABX_B.Product1_h = L4_MABX_B.kph2mps1 * L4_MABX_P.lookAheadTime1_Value;



  /* UnitDelay: '<S401>/Unit Delay1' */

  L4_MABX_B.UnitDelay1 = L4_MABX_DW.UnitDelay1_DSTATE;



  /* Constant: '<S402>/InitialHeading' */

  L4_MABX_B.InitialHeading = L4_MABX_P.InitialHeading_Value;



  /* Constant: '<S402>/InitialPosition' */

  L4_MABX_B.InitialPosition = L4_MABX_P.InitialPosition_Value;



  /* Constant: '<S402>/InitialXPosition' */

  L4_MABX_B.InitialXPosition = L4_MABX_P.InitialXPosition_Value;



  /* Constant: '<S402>/InitialYPosition' */

  L4_MABX_B.InitialYPosition = L4_MABX_P.InitialYPosition_Value;



  /* Gain: '<S71>/kph2ms' */

  L4_MABX_B.kph2ms = L4_MABX_P.kph2ms_Gain * L4_MABX_B.FrontAxleSpeed_dvq;



  /* DiscreteIntegrator: '<S402>/LongitudnalPosition' incorporates:

   *  Constant: '<S401>/Constant'

   */

  if ((L4_MABX_P.Constant_Value_p > 0.0) &&

      (L4_MABX_DW.LongitudnalPosition_PrevResetSt <= 0)) {

    L4_MABX_DW.LongitudnalPosition_DSTATE = L4_MABX_B.InitialPosition;

  }



  L4_MABX_B.LongitudnalPosition = L4_MABX_P.LongitudnalPosition_gainval *

    L4_MABX_B.kph2ms + L4_MABX_DW.LongitudnalPosition_DSTATE;



  /* End of DiscreteIntegrator: '<S402>/LongitudnalPosition' */



  /* Trigonometry: '<S402>/Trigonometric Function' */

  L4_MABX_B.TrigonometricFunction = sin(L4_MABX_B.kph2ms);



  /* Trigonometry: '<S402>/Trigonometric Function1' */

  L4_MABX_B.TrigonometricFunction1 = cos(L4_MABX_B.kph2ms);



  /* DiscreteIntegrator: '<S402>/VehHeading' incorporates:

   *  Constant: '<S402>/reset'

   */

  if ((L4_MABX_P.reset_Value > 0.0) && (L4_MABX_DW.VehHeading_PrevResetState <=

       0)) {

    L4_MABX_DW.VehHeading_DSTATE = L4_MABX_B.InitialHeading;

  }



  L4_MABX_B.VehHeading = L4_MABX_P.VehHeading_gainval *

    L4_MABX_B.TmpRTBAtVehHeadingInport1 + L4_MABX_DW.VehHeading_DSTATE;



  /* End of DiscreteIntegrator: '<S402>/VehHeading' */



  /* DiscreteIntegrator: '<S402>/XPosition' incorporates:

   *  Constant: '<S402>/reset'

   */

  if ((L4_MABX_P.reset_Value > 0.0) && (L4_MABX_DW.XPosition_PrevResetState <= 0))

  {

    L4_MABX_DW.XPosition_DSTATE = L4_MABX_B.InitialXPosition;

  }



  L4_MABX_B.XPosition = L4_MABX_P.XPosition_gainval *

    L4_MABX_B.TrigonometricFunction1 + L4_MABX_DW.XPosition_DSTATE;



  /* End of DiscreteIntegrator: '<S402>/XPosition' */



  /* DiscreteIntegrator: '<S402>/YPosition' incorporates:

   *  Constant: '<S402>/reset'

   */

  if ((L4_MABX_P.reset_Value > 0.0) && (L4_MABX_DW.YPosition_PrevResetState <= 0))

  {

    L4_MABX_DW.YPosition_DSTATE = L4_MABX_B.InitialYPosition;

  }



  L4_MABX_B.YPosition = L4_MABX_P.YPosition_gainval *

    L4_MABX_B.TrigonometricFunction + L4_MABX_DW.YPosition_DSTATE;



  /* End of DiscreteIntegrator: '<S402>/YPosition' */

  /* End of Outputs for SubSystem: '<S65>/Task_20ms' */



  /* UnitDelay: '<S3>/Unit_Delay' */

  L4_MABX_B.S = L4_MABX_DW.Unit_Delay_49_DSTATE;

  L4_MABX_B.B = L4_MABX_DW.Unit_Delay_50_DSTATE;

  L4_MABX_B.X = L4_MABX_DW.Unit_Delay_51_DSTATE;

  L4_MABX_B.Y = L4_MABX_DW.Unit_Delay_52_DSTATE;

  L4_MABX_B.pathCurveOffset = L4_MABX_DW.Unit_Delay_53_DSTATE;

  L4_MABX_B.S_b = L4_MABX_DW.Unit_Delay_54_DSTATE;

  L4_MABX_B.distanceSpdTarget = L4_MABX_DW.Unit_Delay_55_DSTATE;

  L4_MABX_B.state = L4_MABX_DW.Unit_Delay_56_DSTATE;

  L4_MABX_B.lastWayPointIdx = L4_MABX_DW.Unit_Delay_57_DSTATE;

  L4_MABX_B.crossed = L4_MABX_DW.Unit_Delay_58_DSTATE;

  L4_MABX_B.minimumDist = L4_MABX_DW.Unit_Delay_59_DSTATE;

  L4_MABX_B.SrefOnthisPath = L4_MABX_DW.Unit_Delay_60_DSTATE;

  L4_MABX_B.StartDist = L4_MABX_DW.Unit_Delay_61_DSTATE;

  L4_MABX_B.minDistIdx = L4_MABX_DW.Unit_Delay_62_DSTATE;

  L4_MABX_B.pathS = L4_MABX_DW.Unit_Delay_63_DSTATE;

  L4_MABX_B.pathLat = L4_MABX_DW.Unit_Delay_64_DSTATE;

  L4_MABX_B.pathLong = L4_MABX_DW.Unit_Delay_65_DSTATE;

  L4_MABX_B.pathSteeringAngle = L4_MABX_DW.Unit_Delay_66_DSTATE;

  L4_MABX_B.pathSpdLimit = L4_MABX_DW.Unit_Delay_67_DSTATE;

  L4_MABX_B.distance = L4_MABX_DW.Unit_Delay_68_DSTATE;

  L4_MABX_B.idx = L4_MABX_DW.Unit_Delay_69_DSTATE;

  L4_MABX_B.wpidx = L4_MABX_DW.Unit_Delay_70_DSTATE;

  L4_MABX_B.pathOffset = L4_MABX_DW.Unit_Delay_71_DSTATE;

  L4_MABX_B.sRefDistance = L4_MABX_DW.Unit_Delay_72_DSTATE;

  L4_MABX_B.refDistance = L4_MABX_DW.Unit_Delay_73_DSTATE;

  L4_MABX_B.wpIdx = L4_MABX_DW.Unit_Delay_74_DSTATE;

  L4_MABX_B.previewSteeringAngle_l = L4_MABX_DW.Unit_Delay_75_DSTATE;

  L4_MABX_B.desHeading = L4_MABX_DW.Unit_Delay_76_DSTATE;

  L4_MABX_B.actPreviewDist = L4_MABX_DW.Unit_Delay_77_DSTATE;

  L4_MABX_B.desPreviewDist = L4_MABX_DW.Unit_Delay_78_DSTATE;

  L4_MABX_B.mappingSearchCase = L4_MABX_DW.Unit_Delay_79_DSTATE;



  /* user code (Output function Trailer for TID1) */



  /* XCP Data Capture block: <Root>/RTIEthXCP Data Capture */

  /* EventChannel: 0 */

  if (tid == 0) {

    DSXCP_service(0);

  }



  /* If subsystem generates rate grouping Output functions,

   * when tid is used in Output function for one rate,

   * all Output functions include tid as a local variable.

   * As result, some Output functions may have unused tid.

   */

  UNUSED_PARAMETER(tid);

}



/* Model update function for TID1 */

void L4_MABX_update1(void)             /* Sample time: [0.02s, 0.0s] */

{

  /* Update for Atomic SubSystem: '<S65>/Task_10ms' */

  /* Update for RateTransition: '<S81>/TmpRTBAtSignal Conversion1Inport1' incorporates:

   *  Constant: '<S401>/Constant2'

   */

  L4_MABX_DW.TmpRTBAtSignalConversion1Inport = L4_MABX_P.Constant2_Value_a;



  /* Update for RateTransition: '<S81>/TmpRTBAtSignal Conversion3Inport1' incorporates:

   *  Constant: '<S401>/Constant13'

   */

  L4_MABX_DW.TmpRTBAtSignalConversion3Inport = L4_MABX_P.Constant13_Value;



  /* Update for RateTransition: '<S81>/TmpRTBAtSignal Conversion2Inport1' incorporates:

   *  Constant: '<S401>/Constant14'

   */

  L4_MABX_DW.TmpRTBAtSignalConversion2Inport = L4_MABX_P.Constant14_Value;



  /* Update for RateTransition: '<S80>/TmpRTBAtrad2deg1Inport1' incorporates:

   *  Constant: '<S401>/Constant17'

   */

  L4_MABX_DW.TmpRTBAtrad2deg1Inport1_Buffer0 = L4_MABX_P.Constant17_Value;



  /* Update for RateTransition: '<S80>/TmpRTBAtsignCurveOffsetInport1' incorporates:

   *  Constant: '<S401>/Constant1'

   */

  L4_MABX_DW.TmpRTBAtsignCurveOffsetInport1_ = L4_MABX_P.Constant1_Value_g;



  /* Update for RateTransition: '<S284>/TmpRTBAtAdd2Inport2' incorporates:

   *  Constant: '<S401>/Constant18'

   */

  L4_MABX_DW.TmpRTBAtAdd2Inport2_Buffer0 = L4_MABX_P.Constant18_Value;



  /* End of Update for SubSystem: '<S65>/Task_10ms' */



  /* Update for Atomic SubSystem: '<S855>/CAN_TX_20ms' */



  /* Update for UnitDelay: '<S1017>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_j5 = L4_MABX_B.TmpRTBAtUnit_DelayInport1;



  /* Update for UnitDelay: '<S1040>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_f3 = L4_MABX_B.Operator_ao;



  /* Update for UnitDelay: '<S1041>/Unit Delay' */

  L4_MABX_DW.UnitDelay_DSTATE_em = L4_MABX_B.Switch1_pk;



  /* End of Update for SubSystem: '<S855>/CAN_TX_20ms' */



  /* Update for Atomic SubSystem: '<S65>/Task_20ms' */

  /* Update for UnitDelay: '<S401>/Unit Delay1' */

  L4_MABX_DW.UnitDelay1_DSTATE = L4_MABX_B.LongitudnalPosition;



  /* Update for DiscreteIntegrator: '<S402>/LongitudnalPosition' incorporates:

   *  Constant: '<S401>/Constant'

   */

  L4_MABX_DW.LongitudnalPosition_DSTATE = L4_MABX_P.LongitudnalPosition_gainval *

    L4_MABX_B.kph2ms + L4_MABX_B.LongitudnalPosition;

  if (L4_MABX_P.Constant_Value_p > 0.0) {

    L4_MABX_DW.LongitudnalPosition_PrevResetSt = 1;

  } else if (L4_MABX_P.Constant_Value_p < 0.0) {

    L4_MABX_DW.LongitudnalPosition_PrevResetSt = -1;

  } else if (L4_MABX_P.Constant_Value_p == 0.0) {

    L4_MABX_DW.LongitudnalPosition_PrevResetSt = 0;

  } else {

    L4_MABX_DW.LongitudnalPosition_PrevResetSt = 2;

  }



  /* End of Update for DiscreteIntegrator: '<S402>/LongitudnalPosition' */



  /* Update for DiscreteIntegrator: '<S402>/VehHeading' incorporates:

   *  Constant: '<S402>/reset'

   *  DiscreteIntegrator: '<S402>/XPosition'

   */

  L4_MABX_DW.VehHeading_DSTATE = L4_MABX_P.VehHeading_gainval *

    L4_MABX_B.TmpRTBAtVehHeadingInport1 + L4_MABX_B.VehHeading;

  if (L4_MABX_P.reset_Value > 0.0) {

    L4_MABX_DW.VehHeading_PrevResetState = 1;

    L4_MABX_DW.XPosition_PrevResetState = 1;

  } else {

    if (L4_MABX_P.reset_Value < 0.0) {

      L4_MABX_DW.VehHeading_PrevResetState = -1;

    } else if (L4_MABX_P.reset_Value == 0.0) {

      L4_MABX_DW.VehHeading_PrevResetState = 0;

    } else {

      L4_MABX_DW.VehHeading_PrevResetState = 2;

    }



    if (L4_MABX_P.reset_Value < 0.0) {

      L4_MABX_DW.XPosition_PrevResetState = -1;

    } else if (L4_MABX_P.reset_Value == 0.0) {

      L4_MABX_DW.XPosition_PrevResetState = 0;

    } else {

      L4_MABX_DW.XPosition_PrevResetState = 2;

    }

  }



  /* End of Update for DiscreteIntegrator: '<S402>/VehHeading' */



  /* Update for DiscreteIntegrator: '<S402>/XPosition' */

  L4_MABX_DW.XPosition_DSTATE = L4_MABX_P.XPosition_gainval *

    L4_MABX_B.TrigonometricFunction1 + L4_MABX_B.XPosition;



  /* Update for DiscreteIntegrator: '<S402>/YPosition' incorporates:

   *  Constant: '<S402>/reset'

   */

  L4_MABX_DW.YPosition_DSTATE = L4_MABX_P.YPosition_gainval *

    L4_MABX_B.TrigonometricFunction + L4_MABX_B.YPosition;

  if (L4_MABX_P.reset_Value > 0.0) {

    L4_MABX_DW.YPosition_PrevResetState = 1;

  } else if (L4_MABX_P.reset_Value < 0.0) {

    L4_MABX_DW.YPosition_PrevResetState = -1;

  } else if (L4_MABX_P.reset_Value == 0.0) {

    L4_MABX_DW.YPosition_PrevResetState = 0;

  } else {

    L4_MABX_DW.YPosition_PrevResetState = 2;

  }



  /* End of Update for DiscreteIntegrator: '<S402>/YPosition' */

  /* End of Update for SubSystem: '<S65>/Task_20ms' */



  /* Update for UnitDelay: '<S3>/Unit_Delay' incorporates:

   *  Constant: '<S401>/Constant1'

   *  Constant: '<S401>/Constant10'

   *  Constant: '<S401>/Constant11'

   *  Constant: '<S401>/Constant12'

   *  Constant: '<S401>/Constant13'

   *  Constant: '<S401>/Constant14'

   *  Constant: '<S401>/Constant15'

   *  Constant: '<S401>/Constant16'

   *  Constant: '<S401>/Constant17'

   *  Constant: '<S401>/Constant18'

   *  Constant: '<S401>/Constant19'

   *  Constant: '<S401>/Constant2'

   *  Constant: '<S401>/Constant20'

   *  Constant: '<S401>/Constant21'

   *  Constant: '<S401>/Constant22'

   *  Constant: '<S401>/Constant23'

   *  Constant: '<S401>/Constant24'

   *  Constant: '<S401>/Constant25'

   *  Constant: '<S401>/Constant3'

   *  Constant: '<S401>/Constant4'

   *  Constant: '<S401>/Constant5'

   *  Constant: '<S401>/Constant6'

   *  Constant: '<S401>/Constant7'

   *  Constant: '<S401>/Constant8'

   *  Constant: '<S401>/Constant9'

   */

  L4_MABX_DW.Unit_Delay_49_DSTATE = L4_MABX_B.LongitudnalPosition;

  L4_MABX_DW.Unit_Delay_50_DSTATE = L4_MABX_B.VehHeading;

  L4_MABX_DW.Unit_Delay_51_DSTATE = L4_MABX_B.XPosition;

  L4_MABX_DW.Unit_Delay_52_DSTATE = L4_MABX_B.YPosition;

  L4_MABX_DW.Unit_Delay_53_DSTATE = L4_MABX_P.Constant1_Value_g;

  L4_MABX_DW.Unit_Delay_54_DSTATE = L4_MABX_B.UnitDelay1;

  L4_MABX_DW.Unit_Delay_55_DSTATE = L4_MABX_P.Constant2_Value_a;

  L4_MABX_DW.Unit_Delay_56_DSTATE = L4_MABX_P.Constant3_Value_l;

  L4_MABX_DW.Unit_Delay_57_DSTATE = L4_MABX_P.Constant4_Value_m;

  L4_MABX_DW.Unit_Delay_58_DSTATE = L4_MABX_P.Constant5_Value_b;

  L4_MABX_DW.Unit_Delay_59_DSTATE = L4_MABX_P.Constant10_Value_h;

  L4_MABX_DW.Unit_Delay_60_DSTATE = L4_MABX_P.Constant25_Value;

  L4_MABX_DW.Unit_Delay_61_DSTATE = L4_MABX_P.Constant6_Value_e;

  L4_MABX_DW.Unit_Delay_62_DSTATE = L4_MABX_P.Constant7_Value;

  L4_MABX_DW.Unit_Delay_63_DSTATE = L4_MABX_P.Constant8_Value;

  L4_MABX_DW.Unit_Delay_64_DSTATE = L4_MABX_P.Constant9_Value_m;

  L4_MABX_DW.Unit_Delay_65_DSTATE = L4_MABX_P.Constant11_Value;

  L4_MABX_DW.Unit_Delay_66_DSTATE = L4_MABX_P.Constant12_Value;

  L4_MABX_DW.Unit_Delay_67_DSTATE = L4_MABX_P.Constant13_Value;

  L4_MABX_DW.Unit_Delay_68_DSTATE = L4_MABX_P.Constant14_Value;

  L4_MABX_DW.Unit_Delay_69_DSTATE = L4_MABX_P.Constant19_Value_m;

  L4_MABX_DW.Unit_Delay_70_DSTATE = L4_MABX_P.Constant16_Value;

  L4_MABX_DW.Unit_Delay_71_DSTATE = L4_MABX_P.Constant21_Value_g;

  L4_MABX_DW.Unit_Delay_72_DSTATE = L4_MABX_P.Constant22_Value;

  L4_MABX_DW.Unit_Delay_73_DSTATE = L4_MABX_P.Constant15_Value;

  L4_MABX_DW.Unit_Delay_74_DSTATE = L4_MABX_P.Constant20_Value_i;

  L4_MABX_DW.Unit_Delay_75_DSTATE = L4_MABX_P.Constant17_Value;

  L4_MABX_DW.Unit_Delay_76_DSTATE = L4_MABX_P.Constant18_Value;

  L4_MABX_DW.Unit_Delay_77_DSTATE = L4_MABX_P.Constant23_Value;

  L4_MABX_DW.Unit_Delay_78_DSTATE = L4_MABX_B.Product_c;

  L4_MABX_DW.Unit_Delay_79_DSTATE = L4_MABX_P.Constant24_Value;

}



/* Model output function for TID2 */

void L4_MABX_output2(void)             /* Sample time: [0.05s, 0.0s] */

{

  int_T tid = 2;



  /* Outputs for Atomic SubSystem: '<S855>/CAN_TX_50ms' */



  /* Outputs for Enabled SubSystem: '<S1060>/CCVS1_E3' incorporates:

   *  EnablePort: '<S1062>/Enable'

   */

  /* Constant: '<S864>/enable_CAN_TX_CCVS1_CAN3' */

  if (L4_MABX_P.enable_CAN_TX_CCVS1_CAN3_Value > 0.0) {

    /* S-Function (rti_commonblock): '<S1062>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "CCVS1_E3" Id:419361251 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FEF1E3]);



      /* Convert timestamp */

      if (can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FEF1E3]->processed) {

        can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FEF1E3]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FEF1E3]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FEF1E3]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_kr = (real_T)

          can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FEF1E3]->processed;

        L4_MABX_B.SFunction1_o2_p = (real_T)

          can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FEF1E3]->timestamp;

        L4_MABX_B.SFunction1_o3_m = (real_T)

          can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FEF1E3]->deltatime;

        L4_MABX_B.SFunction1_o4_h = (real_T)

          can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FEF1E3]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "SPN69_TwoSpeedAxleSwitch" (0|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.TwoSpeedAxleSwitch ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN70_ParkingBrakeSwitch" (2|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ParkingBrakeSwitch ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN1633_CruiseControlPauseSwitch" (4|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlPauseSwitch ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN3807_ParkBrakeReleaseInhReq" (6|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ParkBrakeReleaseInhibitRq )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN84_WheelBasedVehicleSpeed" (8|16, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.WheelBasedVehicleSpeed_p - (

          0 ) ) / 0.00390625 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte1;



        /* ...... "SPN595_CruiseControlActive" (24|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlActive ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN596_CruiseControlEnableSwitch" (26|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlEnableSwitch_n ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN597_BrakeSwitch" (28|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.BrakeSwitch_n ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN598_ClutchSwitch" (30|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ClutchSwitch ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN599_CruiseControlSetSwitch" (32|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlSetSwitch ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN600_CruiseControlCoastDecelSw" (34|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlCoastSwitch ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN601_CruiseControlResumeSwitch" (36|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlResumeSwitch ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN602_CruiseControlAccelerateSw" (38|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlAccelerateSwitch )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN86_CruiseControlSetSpeed" (40|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlSetSpeed ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN976_PTOGovernorState" (48|5, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.PTOGovernorState ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000001F;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN527_CruiseControlStates" (53|3, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlStates ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000007;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 5;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN968_EngIdleIncrementSw" (56|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.EngIdleIncrementSwitch ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN967_EngIdleDecrementSwitch" (58|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.EngIdleDecrementSwitch ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN966_EngDiagTestModeSwitch" (60|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.EngTestModeSwitch ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN1237_EngShutdownOvrdSwitch" (62|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.EngShutdownOverrideSwitch )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;

      }



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FEF1E3], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  /* End of Constant: '<S864>/enable_CAN_TX_CCVS1_CAN3' */

  /* End of Outputs for SubSystem: '<S1060>/CCVS1_E3' */



  /* Outputs for Enabled SubSystem: '<S1061>/TC1_03_05' incorporates:

   *  EnablePort: '<S1063>/Enable'

   */

  /* Constant: '<S1061>/CANT_TC1_03_05_APV' */

  if (L4_MABX_P.CANT_TC1_03_05_APV_Value) {

    /* S-Function (rti_commonblock): '<S1063>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "TC1_03_05" Id:201392901 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0XC010305]);



      /* Convert timestamp */

      if (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0XC010305]->processed) {

        can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0XC010305]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0XC010305]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0XC010305]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_a = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0XC010305]->processed;

        L4_MABX_B.SFunction1_o2_h = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0XC010305]->timestamp;

        L4_MABX_B.SFunction1_o3_e = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0XC010305]->deltatime;

        L4_MABX_B.SFunction1_o4_f = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0XC010305]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "SPN681_TransGearShiftInhibitReq" (0|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32)

          (( L4_MABX_B.SPN681_TransGearShiftInhibitReq ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN682_TransTrqConvLockupDisReq" (2|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32)

          (( L4_MABX_B.SPN682_TransTrqConvLockupDisReq ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN683_DisengageDrivelineReq" (4|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.SPN683_DisengageDrivelineReq

          ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN4242_TransRevGearShiftInhibRq" (6|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32)

          (( L4_MABX_B.SPN4242_TransRevGearShiftInhibR ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN684_RequestedPercClutchSlip" (8|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32)

          (( L4_MABX_B.SPN684_RequestedPercClutchSlip - ( 0 ) ) / 0.4 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN525_TransRequestedGear" (16|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (L4_MABX_B.SPN525_TransRequestedGear - (

          -125 ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN685_DisengageDiffLockRqFrAx1" (24|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32)

          (( L4_MABX_B.SPN685_DisengageDiffLockRqFrAx1 ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN686_DisengageDiffLockRqFrAx2" (26|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32)

          (( L4_MABX_B.SPN686_DisengageDiffLockRqFrAx2 ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN687_DisengageDiffLockRqRrAx1" (28|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32)

          (( L4_MABX_B.SPN687_DisengageDiffLockRqRrAx1 ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN688_DisengageDiffLockRqRrAx2" (30|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32)

          (( L4_MABX_B.SPN688_DisengageDiffLockRqRrAx2 ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN689_DisengageDiffLockRqC" (32|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.SPN689_DisengageDiffLockRqC )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN690_DisengageDiffLockRqCF" (34|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.SPN690_DisengageDiffLockRqCF

          ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN691_DisengageDiffLockRqCR" (36|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.SPN691_DisengageDiffLockRqCR

          ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN5762_TransLoadRedInhibitRq" (38|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32)

          (( L4_MABX_B.SPN5762_TransLoadRedInhibitRq ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN1852_TransmissionMode1" (40|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.SPN1852_TransmissionMode1 )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN1853_TransmissionMode2" (42|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.SPN1853_TransmissionMode2 )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN1854_TransmissionMode3" (44|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.SPN1854_TransmissionMode3 )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN1855_TransmissionMode4" (46|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.SPN1855_TransmissionMode4 )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN7695_TransAutoNeutralRequest" (48|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32)

          (( L4_MABX_B.SPN7695_TransAutoNeutralRequest ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN4255_TransRequestedLaunchGear" (50|4, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32)

          (( L4_MABX_B.SPN4255_TransRequestedLaunchGea ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000000F;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN2985_TransShiftSelDispModeSw" (54|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32)

          (( L4_MABX_B.SPN2985_TransShiftSelDispModeSw ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN4246_TransmissionMode5" (56|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.SPN4246_TransmissionMode5 )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN4247_TransmissionMode6" (58|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.SPN4247_TransmissionMode6 )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN4248_TransmissionMode7" (60|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.SPN4248_TransmissionMode7 )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SPN4249_TransmissionMode8" (62|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.SPN4249_TransmissionMode8 )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;

      }



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0XC010305], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  /* End of Constant: '<S1061>/CANT_TC1_03_05_APV' */

  /* End of Outputs for SubSystem: '<S1061>/TC1_03_05' */



  /* End of Outputs for SubSystem: '<S855>/CAN_TX_50ms' */

  /* user code (Output function Trailer for TID2) */



  /* XCP Data Capture block: <Root>/RTIEthXCP Data Capture */

  /* EventChannel: 0 */

  if (tid == 0) {

    DSXCP_service(0);

  }



  /* If subsystem generates rate grouping Output functions,

   * when tid is used in Output function for one rate,

   * all Output functions include tid as a local variable.

   * As result, some Output functions may have unused tid.

   */

  UNUSED_PARAMETER(tid);

}



/* Model update function for TID2 */

void L4_MABX_update2(void)             /* Sample time: [0.05s, 0.0s] */

{

  /* (no update code required) */

}



/* Model output function for TID3 */

void L4_MABX_output3(void)             /* Sample time: [0.1s, 0.0s] */

{

  int_T tid = 3;

  uint16_T tmp;

  uint32_T tmp_0;

  uint8_T tmp_1;

  real_T tmp_2;



  /* Outputs for Atomic SubSystem: '<S855>/CAN_TX_100ms' */



  /* DataTypeConversion: '<S892>/Data Type Conversion' incorporates:

   *  Constant: '<S859>/PROPB_XPR_INHIBIT_PARK_MANUAL_APV'

   */

  L4_MABX_B.DataTypeConversion_pk = (uint8_T)

    L4_MABX_P.PROPB_XPR_INHIBIT_PARK_MANUAL_A;



  /* S-Function (sfix_bitop): '<S924>/Operator' */

  L4_MABX_B.Operator_nz = (uint8_T)(L4_MABX_B.DataTypeConversion_pk &

    L4_MABX_P.Operator_BitMask_a);



  /* DataTypeConversion: '<S924>/DataType' */

  L4_MABX_B.DataType_is = L4_MABX_B.Operator_nz;



  /* DataTypeConversion: '<S892>/Data Type Conversion2' incorporates:

   *  Constant: '<S859>/PROPB_XPR_INHIBIT_UNPARK_MANUAL_APV'

   */

  L4_MABX_B.DataTypeConversion2_a2j = (uint8_T)

    L4_MABX_P.PROPB_XPR_INHIBIT_UNPARK_MANUAL;



  /* S-Function (sfix_bitop): '<S926>/Operator' */

  L4_MABX_B.Operator_f4 = (uint8_T)(L4_MABX_B.DataTypeConversion2_a2j &

    L4_MABX_P.Operator_BitMask_l);



  /* DataTypeConversion: '<S926>/DataType' */

  L4_MABX_B.DataType_lm = L4_MABX_B.Operator_f4;



  /* ArithShift: '<S892>/Shift_Arithmetic ' */

  L4_MABX_B.Shift_Arithmetic_jl = (uint8_T)(L4_MABX_B.DataType_lm << 2);



  /* DataTypeConversion: '<S892>/Data Type Conversion4' incorporates:

   *  Constant: '<S859>/PROPB_XPR_PARK_MANUAL_APV'

   */

  L4_MABX_B.DataTypeConversion4_k = (uint8_T)

    L4_MABX_P.PROPB_XPR_PARK_MANUAL_APV_Value;



  /* S-Function (sfix_bitop): '<S927>/Operator' */

  L4_MABX_B.Operator_mst = (uint8_T)(L4_MABX_B.DataTypeConversion4_k &

    L4_MABX_P.Operator_BitMask_kv);



  /* DataTypeConversion: '<S927>/DataType' */

  L4_MABX_B.DataType_d3 = L4_MABX_B.Operator_mst;



  /* ArithShift: '<S892>/Shift_Arithmetic 1' */

  L4_MABX_B.Shift_Arithmetic1_k1 = (uint8_T)(L4_MABX_B.DataType_d3 << 4);



  /* DataTypeConversion: '<S892>/Data Type Conversion5' incorporates:

   *  Constant: '<S859>/PROPB_XPR_UNPARK_MANUAL_APV'

   */

  L4_MABX_B.DataTypeConversion5_n = (uint8_T)

    L4_MABX_P.PROPB_XPR_UNPARK_MANUAL_APV_Val;



  /* S-Function (sfix_bitop): '<S925>/Operator' */

  L4_MABX_B.Operator_mp = (uint8_T)(L4_MABX_B.DataTypeConversion5_n &

    L4_MABX_P.Operator_BitMask_lj);



  /* DataTypeConversion: '<S925>/DataType' */

  L4_MABX_B.DataType_mr = L4_MABX_B.Operator_mp;



  /* ArithShift: '<S892>/Shift_Arithmetic 2' */

  L4_MABX_B.Shift_Arithmetic2_jb = (uint8_T)(L4_MABX_B.DataType_mr << 6);



  /* S-Function (sfix_bitop): '<S932>/Operator' */

  L4_MABX_B.Operator_h5 = (uint8_T)(L4_MABX_B.DataType_is |

    L4_MABX_B.Shift_Arithmetic_jl | L4_MABX_B.Shift_Arithmetic1_k1 |

    L4_MABX_B.Shift_Arithmetic2_jb);



  /* DataTypeConversion: '<S932>/DataType' */

  L4_MABX_B.DataType_ib = L4_MABX_B.Operator_h5;



  /* Outputs for Enabled SubSystem: '<S892>/Rolling_15_counter' incorporates:

   *  EnablePort: '<S934>/Enable'

   */

  if (L4_MABX_B.TmpRTBAtHiddenBuf_InsertedFor_R) {

    /* UnitDelay: '<S934>/Unit_Delay' */

    L4_MABX_B.Unit_Delay = L4_MABX_DW.Unit_Delay_DSTATE;



    /* Sum: '<S942>/FixPt Sum1' incorporates:

     *  Constant: '<S942>/FixPt Constant'

     */

    L4_MABX_B.FixPtSum1_pc = L4_MABX_B.Unit_Delay +

      L4_MABX_P.FixPtConstant_Value;



    /* Switch: '<S943>/FixPt Switch' incorporates:

     *  Constant: '<S943>/Constant'

     */

    if (L4_MABX_B.FixPtSum1_pc > L4_MABX_P.WrapToZero1_Threshold) {

      L4_MABX_B.FixPtSwitch = L4_MABX_P.Constant_Value_j;

    } else {

      L4_MABX_B.FixPtSwitch = L4_MABX_B.FixPtSum1_pc;

    }



    /* End of Switch: '<S943>/FixPt Switch' */

  }



  /* End of Outputs for SubSystem: '<S892>/Rolling_15_counter' */



  /* DataTypeConversion: '<S892>/Data Type Conversion1' */

  tmp_2 = L4_MABX_B.Unit_Delay;

  if (tmp_2 < 256.0) {

    if (tmp_2 >= 0.0) {

      tmp_1 = (uint8_T)tmp_2;

    } else {

      tmp_1 = 0U;

    }

  } else {

    tmp_1 = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion1_og = tmp_1;



  /* End of DataTypeConversion: '<S892>/Data Type Conversion1' */



  /* S-Function (sfix_bitop): '<S928>/Operator' */

  L4_MABX_B.Operator_m0 = (uint8_T)(L4_MABX_B.DataTypeConversion1_og &

    L4_MABX_P.Operator_BitMask_d2);



  /* DataTypeConversion: '<S928>/DataType' */

  L4_MABX_B.DataType_hu = L4_MABX_B.Operator_m0;



  /* DataTypeConversion: '<S931>/Data Type Conversion' incorporates:

   *  Constant: '<S931>/Priority'

   */

  L4_MABX_B.DataTypeConversion_c2 = L4_MABX_P.Priority_Value;



  /* ArithShift: '<S931>/Shift_Arithmetic ' */

  L4_MABX_B.Shift_Arithmetic_jv = L4_MABX_B.DataTypeConversion_c2 << 26;



  /* DataTypeConversion: '<S931>/Data Type Conversion1' incorporates:

   *  Constant: '<S931>/ExtendedDataPage'

   */

  L4_MABX_B.DataTypeConversion1_hd = L4_MABX_P.ExtendedDataPage_Value;



  /* ArithShift: '<S931>/Shift_Arithmetic 1' */

  L4_MABX_B.Shift_Arithmetic1_g2 = L4_MABX_B.DataTypeConversion1_hd << 25;



  /* DataTypeConversion: '<S931>/Data Type Conversion2' incorporates:

   *  Constant: '<S931>/DataPage'

   */

  L4_MABX_B.DataTypeConversion2_g0 = L4_MABX_P.DataPage_Value;



  /* ArithShift: '<S931>/Shift_Arithmetic 2' */

  L4_MABX_B.Shift_Arithmetic2_fh = L4_MABX_B.DataTypeConversion2_g0 << 24;



  /* DataTypeConversion: '<S931>/Data Type Conversion3' incorporates:

   *  Constant: '<S931>/PDUFormat'

   */

  L4_MABX_B.DataTypeConversion3_a = L4_MABX_P.PDUFormat_Value;



  /* ArithShift: '<S931>/Shift_Arithmetic 3' */

  L4_MABX_B.Shift_Arithmetic3_ap = L4_MABX_B.DataTypeConversion3_a << 16;



  /* DataTypeConversion: '<S931>/Data Type Conversion4' incorporates:

   *  Constant: '<S931>/PDUSpecific'

   */

  L4_MABX_B.DataTypeConversion4_l = L4_MABX_P.PDUSpecific_Value;



  /* ArithShift: '<S931>/Shift_Arithmetic 4' */

  L4_MABX_B.Shift_Arithmetic4_f = L4_MABX_B.DataTypeConversion4_l << 8;



  /* DataTypeConversion: '<S931>/Data Type Conversion5' incorporates:

   *  Constant: '<S931>/SourceAddress'

   */

  L4_MABX_B.DataTypeConversion5_d = L4_MABX_P.SourceAddress_Value;



  /* S-Function (sfix_bitop): '<S941>/Operator' */

  L4_MABX_B.Operator_bi = L4_MABX_B.Shift_Arithmetic_jv |

    L4_MABX_B.Shift_Arithmetic1_g2 | L4_MABX_B.Shift_Arithmetic2_fh |

    L4_MABX_B.Shift_Arithmetic3_ap | L4_MABX_B.Shift_Arithmetic4_f |

    L4_MABX_B.DataTypeConversion5_d;



  /* DataTypeConversion: '<S941>/DataType' */

  L4_MABX_B.DataType_jnf = L4_MABX_B.Operator_bi;



  /* DataTypeConversion: '<S930>/Data Type Conversion8' */

  L4_MABX_B.DataTypeConversion8_hh = L4_MABX_B.DataType_jnf;



  /* S-Function (sfix_bitop): '<S937>/Operator' */

  L4_MABX_B.Operator_au = L4_MABX_B.DataTypeConversion8_hh &

    L4_MABX_P.Operator_BitMask_ix;



  /* DataTypeConversion: '<S937>/DataType' */

  tmp_0 = L4_MABX_B.Operator_au;

  if (tmp_0 > 255U) {

    tmp_0 = 255U;

  }



  L4_MABX_B.DataType_mp = (uint8_T)tmp_0;



  /* End of DataTypeConversion: '<S937>/DataType' */



  /* S-Function (sfix_bitop): '<S938>/Operator' */

  L4_MABX_B.Operator_p = L4_MABX_B.DataTypeConversion8_hh &

    L4_MABX_P.Operator_BitMask_l5;



  /* DataTypeConversion: '<S938>/DataType' */

  tmp_0 = L4_MABX_B.Operator_p;

  if (tmp_0 > 65535U) {

    tmp_0 = 65535U;

  }



  L4_MABX_B.DataType_a2 = (uint16_T)tmp_0;



  /* End of DataTypeConversion: '<S938>/DataType' */



  /* ArithShift: '<S930>/Shift_Arithmetic 3' */

  L4_MABX_B.Shift_Arithmetic3_dh = (uint16_T)((uint32_T)L4_MABX_B.DataType_a2 >>

    8);



  /* DataTypeConversion: '<S930>/Data Type Conversion9' */

  tmp = L4_MABX_B.Shift_Arithmetic3_dh;

  if (tmp > 255) {

    tmp = 255U;

  }



  L4_MABX_B.MessageIDMidLowByte = (uint8_T)tmp;



  /* End of DataTypeConversion: '<S930>/Data Type Conversion9' */



  /* S-Function (sfix_bitop): '<S939>/Operator' */

  L4_MABX_B.Operator_k = L4_MABX_B.DataTypeConversion8_hh &

    L4_MABX_P.Operator_BitMask_ly;



  /* DataTypeConversion: '<S939>/DataType' */

  L4_MABX_B.DataType_hl = L4_MABX_B.Operator_k;



  /* ArithShift: '<S930>/Shift_Arithmetic 4' */

  L4_MABX_B.Shift_Arithmetic4_a = L4_MABX_B.DataType_hl >> 16;



  /* DataTypeConversion: '<S930>/Data Type Conversion10' */

  tmp_0 = L4_MABX_B.Shift_Arithmetic4_a;

  if (tmp_0 > 255U) {

    tmp_0 = 255U;

  }



  L4_MABX_B.MessageIDMidHighByte = (uint8_T)tmp_0;



  /* End of DataTypeConversion: '<S930>/Data Type Conversion10' */



  /* S-Function (sfix_bitop): '<S940>/Operator' */

  L4_MABX_B.Operator_o = L4_MABX_B.DataTypeConversion8_hh &

    L4_MABX_P.Operator_BitMask_kq;



  /* DataTypeConversion: '<S940>/DataType' */

  L4_MABX_B.DataType_bh = L4_MABX_B.Operator_o;



  /* ArithShift: '<S930>/Shift_Arithmetic 5' */

  L4_MABX_B.Shift_Arithmetic5_d = L4_MABX_B.DataType_bh >> 24;



  /* DataTypeConversion: '<S930>/Data Type Conversion11' */

  tmp_0 = L4_MABX_B.Shift_Arithmetic5_d;

  if (tmp_0 > 255U) {

    tmp_0 = 255U;

  }



  L4_MABX_B.MessageIDHighByte = (uint8_T)tmp_0;



  /* End of DataTypeConversion: '<S930>/Data Type Conversion11' */



  /* DataTypeConversion: '<S930>/Data Type Conversion13' */

  tmp_2 = L4_MABX_B.Unit_Delay;

  if (tmp_2 < 256.0) {

    if (tmp_2 >= 0.0) {

      tmp_1 = (uint8_T)tmp_2;

    } else {

      tmp_1 = 0U;

    }

  } else {

    tmp_1 = MAX_uint8_T;

  }



  L4_MABX_B.DataTypeConversion13_b = tmp_1;



  /* End of DataTypeConversion: '<S930>/Data Type Conversion13' */



  /* S-Function (sfix_bitop): '<S936>/Operator' */

  L4_MABX_B.Operator_mpq = (uint8_T)(L4_MABX_B.DataTypeConversion13_b &

    L4_MABX_P.Operator_BitMask_cq);



  /* DataTypeConversion: '<S936>/DataType' */

  L4_MABX_B.DataType_dj = L4_MABX_B.Operator_mpq;



  /* Sum: '<S930>/Add' incorporates:

   *  Constant: '<S892>/Constant3'

   */

  L4_MABX_B.Checksum = (uint8_T)((uint32_T)(uint8_T)((uint32_T)(uint8_T)

    ((uint32_T)(uint8_T)((uint32_T)(uint8_T)((uint32_T)(uint8_T)((uint32_T)

    (uint8_T)((uint32_T)(uint8_T)((uint32_T)(uint8_T)((uint32_T)(uint8_T)

    ((uint32_T)(uint8_T)((uint32_T)L4_MABX_B.DataType_ib +

    L4_MABX_P.Constant3_Value_b) + L4_MABX_P.Constant3_Value_b) +

    L4_MABX_P.Constant3_Value_b) + L4_MABX_P.Constant3_Value_b) +

              L4_MABX_P.Constant3_Value_b) + L4_MABX_P.Constant3_Value_b) +

    L4_MABX_B.DataType_mp) + L4_MABX_B.MessageIDMidLowByte) +

     L4_MABX_B.MessageIDMidHighByte) + L4_MABX_B.MessageIDHighByte) +

    L4_MABX_B.DataType_dj);



  /* ArithShift: '<S930>/Shift_Arithmetic 7' */

  L4_MABX_B.Shift_Arithmetic7_b = (uint8_T)((uint32_T)L4_MABX_B.Checksum >> 4);



  /* Sum: '<S930>/Add1' */

  L4_MABX_B.Add1_a = (uint8_T)((uint32_T)L4_MABX_B.Shift_Arithmetic7_b +

    L4_MABX_B.Checksum);



  /* S-Function (sfix_bitop): '<S935>/Operator' */

  L4_MABX_B.Operator_ml = (uint8_T)(L4_MABX_B.Add1_a &

    L4_MABX_P.Operator_BitMask_fo);



  /* DataTypeConversion: '<S935>/DataType' */

  L4_MABX_B.DataType_kw = L4_MABX_B.Operator_ml;



  /* DataTypeConversion: '<S892>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_ay = L4_MABX_B.DataType_kw;



  /* S-Function (sfix_bitop): '<S929>/Operator' */

  L4_MABX_B.Operator_o1 = (uint8_T)(L4_MABX_B.DataTypeConversion3_ay &

    L4_MABX_P.Operator_BitMask_er);



  /* DataTypeConversion: '<S929>/DataType' */

  L4_MABX_B.DataType_he = L4_MABX_B.Operator_o1;



  /* ArithShift: '<S892>/Shift_Arithmetic 3' */

  L4_MABX_B.Shift_Arithmetic3_hx = (uint8_T)(L4_MABX_B.DataType_he << 4);



  /* S-Function (sfix_bitop): '<S933>/Operator' */

  L4_MABX_B.Operator_cq = (uint8_T)(L4_MABX_B.DataType_hu |

    L4_MABX_B.Shift_Arithmetic3_hx);



  /* DataTypeConversion: '<S933>/DataType' */

  L4_MABX_B.DataType_ff = L4_MABX_B.Operator_cq;



  /* DataTypeConversion: '<S887>/Data Type Conversion1' incorporates:

   *  Constant: '<S892>/Constant3'

   */

  L4_MABX_B.DataTypeConversion1_hv[0] = L4_MABX_B.DataType_ib;

  L4_MABX_B.DataTypeConversion1_hv[1] = L4_MABX_P.Constant3_Value_b;

  L4_MABX_B.DataTypeConversion1_hv[2] = L4_MABX_P.Constant3_Value_b;

  L4_MABX_B.DataTypeConversion1_hv[3] = L4_MABX_P.Constant3_Value_b;

  L4_MABX_B.DataTypeConversion1_hv[4] = L4_MABX_P.Constant3_Value_b;

  L4_MABX_B.DataTypeConversion1_hv[5] = L4_MABX_P.Constant3_Value_b;

  L4_MABX_B.DataTypeConversion1_hv[6] = L4_MABX_P.Constant3_Value_b;

  L4_MABX_B.DataTypeConversion1_hv[7] = L4_MABX_B.DataType_ff;



  /* DataTypeConversion: '<S887>/Data Type Conversion' incorporates:

   *  Constant: '<S859>/CANT_PROPB_XPR_FC_CHANNEL_APV'

   */

  L4_MABX_B.DataTypeConversion_ln = (uint8_T)

    L4_MABX_P.CANT_PROPB_XPR_FC_CHANNEL_APV_V;



  /* S-Function (sfix_bitop): '<S902>/Operator' */

  L4_MABX_B.Operator_im = (uint8_T)(L4_MABX_B.DataTypeConversion_ln &

    L4_MABX_P.Operator_BitMask_ci);



  /* DataTypeConversion: '<S902>/DataType' */

  L4_MABX_B.DataType_cp = L4_MABX_B.Operator_im;



  /* DataTypeConversion: '<S887>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_f1 = (L4_MABX_B.DataType_cp != 0);



  /* Logic: '<S910>/Operator' */

  L4_MABX_B.Operator_jh = (L4_MABX_B.TmpRTBAtOperatorInport1 &&

    L4_MABX_B.DataTypeConversion2_f1);



  /* DataTypeConversion: '<S910>/DataType' */

  L4_MABX_B.DataType_pk = L4_MABX_B.Operator_jh;



  /* Outputs for Enabled SubSystem: '<S914>/PropB_XPR_FC' incorporates:

   *  EnablePort: '<S916>/Enable'

   */

  if (L4_MABX_B.DataType_pk) {

    /* S-Function (rti_commonblock): '<S916>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "PropB_XPR_FC" Id:419366140 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18FF04FC]);



      /* Convert timestamp */

      if (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18FF04FC]->processed) {

        can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18FF04FC]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18FF04FC]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18FF04FC]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_n = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18FF04FC]->processed;

        L4_MABX_B.SFunction1_o2_du = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18FF04FC]->timestamp;

        L4_MABX_B.SFunction1_o3_b1 = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18FF04FC]->deltatime;

        L4_MABX_B.SFunction1_o4_o = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18FF04FC]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "byte1" (0|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_hv[0] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte2" (8|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_hv[1] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte3" (16|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_hv[2] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte4" (24|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_hv[3] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte5" (32|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_hv[4] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte6" (40|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_hv[5] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte7" (48|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_hv[6] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte8" (56|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_hv[7] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;

      }



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18FF04FC], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  /* End of Outputs for SubSystem: '<S914>/PropB_XPR_FC' */



  /* S-Function (sfix_bitop): '<S907>/Operator' */

  L4_MABX_B.Operator_jz = (uint8_T)(L4_MABX_B.DataTypeConversion_ln &

    L4_MABX_P.Operator_BitMask_p);



  /* DataTypeConversion: '<S907>/DataType' */

  L4_MABX_B.DataType_pm = L4_MABX_B.Operator_jz;



  /* ArithShift: '<S887>/Shift_Arithmetic 2' */

  L4_MABX_B.Shift_Arithmetic2_f = ldexp(L4_MABX_B.DataType_pm, (-3));



  /* DataTypeConversion: '<S887>/Data Type Conversion5' */

  L4_MABX_B.DataTypeConversion5_kt = (L4_MABX_B.Shift_Arithmetic2_f != 0.0);



  /* Logic: '<S913>/Operator' */

  L4_MABX_B.Operator_iqn = (L4_MABX_B.TmpRTBAtOperatorInport1_c &&

    L4_MABX_B.DataTypeConversion5_kt);



  /* DataTypeConversion: '<S913>/DataType' */

  L4_MABX_B.DataType_pf = L4_MABX_B.Operator_iqn;



  /* Outputs for Enabled SubSystem: '<S915>/PropB_XPR_FC' incorporates:

   *  EnablePort: '<S917>/Enable'

   */

  if (L4_MABX_B.DataType_pf) {

    /* S-Function (rti_commonblock): '<S917>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "PropB_XPR_FC" Id:419366140 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FF04FC]);



      /* Convert timestamp */

      if (can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FF04FC]->processed) {

        can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FF04FC]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FF04FC]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FF04FC]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_fy = (real_T)

          can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FF04FC]->processed;

        L4_MABX_B.SFunction1_o2_l = (real_T)

          can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FF04FC]->timestamp;

        L4_MABX_B.SFunction1_o3_f0 = (real_T)

          can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FF04FC]->deltatime;

        L4_MABX_B.SFunction1_o4_p = (real_T)

          can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FF04FC]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "byte1" (0|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_hv[0] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte2" (8|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_hv[1] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte3" (16|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_hv[2] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte4" (24|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_hv[3] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte5" (32|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_hv[4] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte6" (40|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_hv[5] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte7" (48|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_hv[6] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte8" (56|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_hv[7] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;

      }



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FF04FC], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  /* End of Outputs for SubSystem: '<S915>/PropB_XPR_FC' */



  /* S-Function (sfix_bitop): '<S903>/Operator' */

  L4_MABX_B.Operator_fn = (uint8_T)(L4_MABX_B.DataTypeConversion_ln &

    L4_MABX_P.Operator_BitMask_i);



  /* DataTypeConversion: '<S903>/DataType' */

  L4_MABX_B.DataType_e2 = L4_MABX_B.Operator_fn;



  /* S-Function (sfix_bitop): '<S908>/Operator' */

  L4_MABX_B.Operator_bs = (uint8_T)(L4_MABX_B.DataTypeConversion_ln &

    L4_MABX_P.Operator_BitMask_gt);



  /* DataTypeConversion: '<S908>/DataType' */

  L4_MABX_B.DataType_n = L4_MABX_B.Operator_bs;



  /* ArithShift: '<S887>/Shift_Arithmetic 3' */

  L4_MABX_B.Shift_Arithmetic3_a = ldexp(L4_MABX_B.DataType_n, (-4));



  /* DataTypeConversion: '<S887>/Data Type Conversion6' */

  L4_MABX_B.DataTypeConversion6_py = (L4_MABX_B.Shift_Arithmetic3_a != 0.0);



  /* Logic: '<S904>/Operator' */

  L4_MABX_B.Operator_ary = (L4_MABX_B.TmpRTBAtOperatorInport1_n &&

    L4_MABX_B.DataTypeConversion6_py);



  /* DataTypeConversion: '<S904>/DataType' */

  L4_MABX_B.DataType_ewo = L4_MABX_B.Operator_ary;



  /* S-Function (sfix_bitop): '<S909>/Operator' */

  L4_MABX_B.Operator_cu = (uint8_T)(L4_MABX_B.DataTypeConversion_ln &

    L4_MABX_P.Operator_BitMask_hb);



  /* DataTypeConversion: '<S909>/DataType' */

  L4_MABX_B.DataType_k = L4_MABX_B.Operator_cu;



  /* ArithShift: '<S887>/Shift_Arithmetic 4' */

  L4_MABX_B.Shift_Arithmetic4_i = ldexp(L4_MABX_B.DataType_k, (-5));



  /* DataTypeConversion: '<S887>/Data Type Conversion7' */

  L4_MABX_B.DataTypeConversion7_mh = (L4_MABX_B.Shift_Arithmetic4_i != 0.0);



  /* Logic: '<S905>/Operator' */

  L4_MABX_B.Operator_jg = (L4_MABX_B.TmpRTBAtOperatorInport1_k &&

    L4_MABX_B.DataTypeConversion7_mh);



  /* DataTypeConversion: '<S905>/DataType' */

  L4_MABX_B.DataType_elw = L4_MABX_B.Operator_jg;



  /* S-Function (sfix_bitop): '<S906>/Operator' */

  L4_MABX_B.Operator_l3 = (uint8_T)(L4_MABX_B.DataTypeConversion_ln &

    L4_MABX_P.Operator_BitMask_pp);



  /* DataTypeConversion: '<S906>/DataType' */

  L4_MABX_B.DataType_c = L4_MABX_B.Operator_l3;



  /* ArithShift: '<S887>/Shift_Arithmetic ' */

  L4_MABX_B.Shift_Arithmetic_c = ldexp(L4_MABX_B.DataType_e2, (-1));



  /* DataTypeConversion: '<S887>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_be = (L4_MABX_B.Shift_Arithmetic_c != 0.0);



  /* Logic: '<S911>/Operator' */

  L4_MABX_B.Operator_cc = (L4_MABX_B.TmpRTBAtOperatorInport1_kn &&

    L4_MABX_B.DataTypeConversion3_be);



  /* DataTypeConversion: '<S911>/DataType' */

  L4_MABX_B.DataType_h1s = L4_MABX_B.Operator_cc;



  /* ArithShift: '<S887>/Shift_Arithmetic 1' */

  L4_MABX_B.Shift_Arithmetic1_j = ldexp(L4_MABX_B.DataType_c, (-2));



  /* DataTypeConversion: '<S887>/Data Type Conversion4' */

  L4_MABX_B.DataTypeConversion4_d1 = (L4_MABX_B.Shift_Arithmetic1_j != 0.0);



  /* Logic: '<S912>/Operator' */

  L4_MABX_B.Operator_btn = (L4_MABX_B.TmpRTBAtOperatorInport1_cw &&

    L4_MABX_B.DataTypeConversion4_d1);



  /* DataTypeConversion: '<S912>/DataType' */

  L4_MABX_B.DataType_gsm = L4_MABX_B.Operator_btn;



  /* DataTypeConversion: '<S944>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_p = L4_MABX_B.Latitude__m;



  /* DataTypeConversion: '<S944>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_he = L4_MABX_B.Longitude__a;



  /* DataTypeConversion: '<S893>/Data Type Conversion2' incorporates:

   *  Constant: '<S859>/enablePosRapidUpdateTX'

   */

  L4_MABX_B.DataTypeConversion2_c4 = L4_MABX_P.enablePosRapidUpdateTX_Value;



  /* Outputs for Enabled SubSystem: '<S944>/Std_PosRapidUpdate_01' incorporates:

   *  EnablePort: '<S945>/Enable'

   */

  if (L4_MABX_B.DataTypeConversion2_c4) {

    /* S-Function (rti_commonblock): '<S945>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "Std_PosRapidUpdate_01" Id:3 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0X3]);



      /* Convert timestamp */

      if (can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0X3]->processed) {

        can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0X3]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0X3]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0X3]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_lh = (real_T)

          can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0X3]->processed;

        L4_MABX_B.SFunction1_o2_b0 = (real_T)

          can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0X3]->timestamp;

        L4_MABX_B.SFunction1_o3_bz = (real_T)

          can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0X3]->deltatime;

        L4_MABX_B.SFunction1_o4_n3 = (real_T)

          can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0X3]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "Latitude_" (0|32, standard signal, signed int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        if (( L4_MABX_B.DataTypeConversion_p - ( 0 ) ) / 1.0E-7 < -0.5)

          CAN_Sgn.SignedSgn = (Int32) (( L4_MABX_B.DataTypeConversion_p - ( 0 ) )

            / 1.0E-7 - 0.5);

        else

          CAN_Sgn.SignedSgn = (Int32) (( L4_MABX_B.DataTypeConversion_p - ( 0 ) )

            / 1.0E-7 + 0.5);

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte1;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte2;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte3;



        /* ...... "Longitude_" (32|32, standard signal, signed int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        if (( L4_MABX_B.DataTypeConversion1_he - ( 0 ) ) / 1.0E-7 < -0.5)

          CAN_Sgn.SignedSgn = (Int32) (( L4_MABX_B.DataTypeConversion1_he - ( 0 )

            ) / 1.0E-7 - 0.5);

        else

          CAN_Sgn.SignedSgn = (Int32) (( L4_MABX_B.DataTypeConversion1_he - ( 0 )

            ) / 1.0E-7 + 0.5);

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte1;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte2;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte3;

      }



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0X3], 8, &(CAN_Msg[0]),

                       delayTime);

    }

  }



  /* End of Outputs for SubSystem: '<S944>/Std_PosRapidUpdate_01' */



  /* Outputs for Enabled SubSystem: '<S895>/CCVS1_00' incorporates:

   *  EnablePort: '<S897>/Enable'

   */

  /* Outputs for Enabled SubSystem: '<S894>/CCVS1_00' incorporates:

   *  EnablePort: '<S896>/Enable'

   */

  /* Constant: '<S885>/Enable_TX_CCVS1_00' */

  if (L4_MABX_P.Enable_TX_CCVS1_00_Value) {

    /* S-Function (rti_commonblock): '<S896>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "CCVS1_00" Id:419361024 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M1[CANTP1_M1_C2_TX_XTD_0X18FEF100]);



      /* Convert timestamp */

      if (can_type1_msg_M1[CANTP1_M1_C2_TX_XTD_0X18FEF100]->processed) {

        can_type1_msg_M1[CANTP1_M1_C2_TX_XTD_0X18FEF100]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M1[CANTP1_M1_C2_TX_XTD_0X18FEF100]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M1[CANTP1_M1_C2_TX_XTD_0X18FEF100]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_c = (real_T)

          can_type1_msg_M1[CANTP1_M1_C2_TX_XTD_0X18FEF100]->processed;

        L4_MABX_B.SFunction1_o2_oc = (real_T)

          can_type1_msg_M1[CANTP1_M1_C2_TX_XTD_0X18FEF100]->timestamp;

        L4_MABX_B.SFunction1_o3_h = (real_T)

          can_type1_msg_M1[CANTP1_M1_C2_TX_XTD_0X18FEF100]->deltatime;

        L4_MABX_B.SFunction1_o4_hr = (real_T)

          can_type1_msg_M1[CANTP1_M1_C2_TX_XTD_0X18FEF100]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "TwoSpeedAxleSwitch" (0|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.TwoSpeedAxleSwitch_a ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "ParkingBrakeSwitch" (2|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ParkingBrakeSwitch_m ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "CruiseCtrlPauseSwitch" (4|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlPauseSwitch_e ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "ParkBrakeReleaseInhibitRq" (6|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ParkBrakeReleaseInhibitRq_n )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "WheelBasedVehicleSpeed" (8|16, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.WheelBasedVehicleSpeed_pj -

          ( 0 ) ) / 0.00390625 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte1;



        /* ...... "CruiseCtrlActive" (24|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlActive_i ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "CruiseCtrlEnableSwitch" (26|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlEnableSwitch_n3 )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "BrakeSwitch" (28|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.BrakeSwitch_n4 ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "ClutchSwitch" (30|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ClutchSwitch_l ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "CruiseCtrlSetSwitch" (32|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlSetSwitch_h ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "CruiseCtrlCoastSwitch" (34|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlCoastSwitch_c ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "CruiseCtrlResumeSwitch" (36|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlResumeSwitch_b ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "CruiseCtrlAccelerateSwitch" (38|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlAccelerateSwitch_c

          ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "CruiseCtrlSetSpeed" (40|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlSetSpeed_m ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "PTOGovernorState" (48|5, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.PTOGovernorState_c ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000001F;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "CruiseCtrlStates" (53|3, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlStates_k ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000007;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 5;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "EngIdleIncrementSwitch" (56|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.EngIdleIncrementSwitch_f ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "EngIdleDecrementSwitch" (58|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.EngIdleDecrementSwitch_i ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "EngTestModeSwitch" (60|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.EngTestModeSwitch_d ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "EngShutdownOverrideSwitch" (62|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.EngShutdownOverrideSwitch_p )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;

      }



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M1[CANTP1_M1_C2_TX_XTD_0X18FEF100], 8,

                       &(CAN_Msg[0]), delayTime);

    }



    /* S-Function (rti_commonblock): '<S897>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "CCVS1_00" Id:218034432 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M3[CANTP1_M3_C2_TX_XTD_0XCFEF100]);



      /* Convert timestamp */

      if (can_type1_msg_M3[CANTP1_M3_C2_TX_XTD_0XCFEF100]->processed) {

        can_type1_msg_M3[CANTP1_M3_C2_TX_XTD_0XCFEF100]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M3[CANTP1_M3_C2_TX_XTD_0XCFEF100]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M3[CANTP1_M3_C2_TX_XTD_0XCFEF100]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_i = (real_T)

          can_type1_msg_M3[CANTP1_M3_C2_TX_XTD_0XCFEF100]->processed;

        L4_MABX_B.SFunction1_o2_gv = (real_T)

          can_type1_msg_M3[CANTP1_M3_C2_TX_XTD_0XCFEF100]->timestamp;

        L4_MABX_B.SFunction1_o3_j = (real_T)

          can_type1_msg_M3[CANTP1_M3_C2_TX_XTD_0XCFEF100]->deltatime;

        L4_MABX_B.SFunction1_o4_fm = (real_T)

          can_type1_msg_M3[CANTP1_M3_C2_TX_XTD_0XCFEF100]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "TwoSpeedAxleSwitch" (0|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.TwoSpeedAxleSwitch_ay ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "ParkingBrakeSwitch" (2|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ParkingBrakeSwitch_md ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "CruiseCtrlPauseSwitch" (4|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlPauseSwitch_eq ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "ParkBrakeReleaseInhibitRq" (6|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ParkBrakeReleaseInhibitRq_n0

          ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "WheelBasedVehicleSpeed" (8|16, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.WheelBasedVehicleSpeed_pjm -

          ( 0 ) ) / 0.00390625 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte1;



        /* ...... "CruiseCtrlActive" (24|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlActive_iq ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "CruiseCtrlEnableSwitch" (26|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlEnableSwitch_n3b )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "BrakeSwitch" (28|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.BrakeSwitch_n4h ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "ClutchSwitch" (30|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ClutchSwitch_lp ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "CruiseCtrlSetSwitch" (32|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlSetSwitch_hj ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "CruiseCtrlCoastSwitch" (34|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlCoastSwitch_cs ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "CruiseCtrlResumeSwitch" (36|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlResumeSwitch_b4 )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "CruiseCtrlAccelerateSwitch" (38|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32)

          (( L4_MABX_B.CruiseCtrlAccelerateSwitch_ci ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "CruiseCtrlSetSpeed" (40|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlSetSpeed_mm ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "PTOGovernorState" (48|5, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.PTOGovernorState_cv ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000001F;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "CruiseCtrlStates" (53|3, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CruiseCtrlStates_ks ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000007;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 5;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "EngIdleIncrementSwitch" (56|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.EngIdleIncrementSwitch_f1 )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "EngIdleDecrementSwitch" (58|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.EngIdleDecrementSwitch_il )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "EngTestModeSwitch" (60|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.EngTestModeSwitch_d0 ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "EngShutdownOverrideSwitch" (62|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.EngShutdownOverrideSwitch_pi

          ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;

      }



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M3[CANTP1_M3_C2_TX_XTD_0XCFEF100], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  /* End of Constant: '<S885>/Enable_TX_CCVS1_00' */

  /* End of Outputs for SubSystem: '<S894>/CCVS1_00' */

  /* End of Outputs for SubSystem: '<S895>/CCVS1_00' */



  /* DataTypeConversion: '<S891>/Data Type Conversion' incorporates:

   *  Constant: '<S890>/Constant'

   */

  L4_MABX_B.DataTypeConversion_dl = L4_MABX_P.Constant_Value_jk;



  /* DataTypeConversion: '<S891>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_cd = (uint16_T)L4_MABX_B.DataTypeConversion_dl;



  /* S-Function (sfix_bitop): '<S922>/Operator' */

  L4_MABX_B.Operator_e2q = (uint16_T)(L4_MABX_B.DataTypeConversion1_cd &

    L4_MABX_P.Operator_BitMask_dx);



  /* DataTypeConversion: '<S922>/DataType' */

  tmp = L4_MABX_B.Operator_e2q;

  if (tmp > 255) {

    tmp = 255U;

  }



  L4_MABX_B.DataType_as = (uint8_T)tmp;



  /* End of DataTypeConversion: '<S922>/DataType' */



  /* S-Function (sfix_bitop): '<S923>/Operator' */

  L4_MABX_B.Operator_oc = (uint16_T)(L4_MABX_B.DataTypeConversion1_cd &

    L4_MABX_P.Operator_BitMask_jf);



  /* DataTypeConversion: '<S923>/DataType' */

  L4_MABX_B.DataType_mv = L4_MABX_B.Operator_oc;



  /* ArithShift: '<S891>/Shift_Arithmetic ' */

  L4_MABX_B.Shift_Arithmetic_o4 = (uint16_T)((uint32_T)L4_MABX_B.DataType_mv >>

    8);



  /* DataTypeConversion: '<S891>/Data Type Conversion2' */

  tmp = L4_MABX_B.Shift_Arithmetic_o4;

  if (tmp > 255) {

    tmp = 255U;

  }



  L4_MABX_B.DataTypeConversion2_mp = (uint8_T)tmp;



  /* End of DataTypeConversion: '<S891>/Data Type Conversion2' */



  /* DataTypeConversion: '<S886>/Data Type Conversion1' incorporates:

   *  Constant: '<S891>/Constant'

   */

  L4_MABX_B.DataTypeConversion1_ff[0] = L4_MABX_P.Constant_Value_fh;

  L4_MABX_B.DataTypeConversion1_ff[1] = L4_MABX_P.Constant_Value_fh;

  L4_MABX_B.DataTypeConversion1_ff[2] = L4_MABX_P.Constant_Value_fh;

  L4_MABX_B.DataTypeConversion1_ff[3] = L4_MABX_P.Constant_Value_fh;

  L4_MABX_B.DataTypeConversion1_ff[4] = L4_MABX_P.Constant_Value_fh;

  L4_MABX_B.DataTypeConversion1_ff[5] = L4_MABX_P.Constant_Value_fh;

  L4_MABX_B.DataTypeConversion1_ff[6] = L4_MABX_B.DataType_as;

  L4_MABX_B.DataTypeConversion1_ff[7] = L4_MABX_B.DataTypeConversion2_mp;



  /* RateTransition: '<S898>/TmpRTBAtHiddenBuf_InsertedFor_PropB_REAX_5_E4_at_inport_10Inport1' */

  L4_MABX_B.TmpRTBAtHiddenBuf_InsertedFor_P = L4_MABX_B.Operator_nc;



  /* Outputs for Enabled SubSystem: '<S898>/PropB_REAX_5_E4' incorporates:

   *  EnablePort: '<S900>/Enable'

   */

  if (L4_MABX_B.TmpRTBAtHiddenBuf_InsertedFor_P) {

    /* S-Function (rti_commonblock): '<S900>/S-Function1' incorporates:

     *  Constant: '<S898>/Constant'

     *  Constant: '<S898>/Constant1'

     */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "PropB_REAX_5_E4" Id:419429092 */

    {

      static UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        0x00 };



      Float32 delayTime = 0.0;



      /* link this pointer to CAN_Msg for use in initialize_io_units() */

      CANTP1_PTR_M1_C2_XTD_0x18FFFAE4 = &(CAN_Msg[0]);



      /* ... perform loop-back if required */

      if (L4_MABX_P.Constant1_Value_cb > 0.5) {

        /* ... updating the used tx-clientbuffer */

        can_tp1_msg_update_all( CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFFAE4->module,

          CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFFAE4->queue );



        /* ... Read status and timestamp info perform loop-back (previous message) */

        can_tp1_tx_msg_read_loopback(CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFFAE4,

          8,                           // datalen

          &(CAN_Msg[0]),

          CANTP1_RX_SPMSG_M1_C2_XTD);



        /* Convert timestamp */

        if (CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFFAE4->processed) {

          CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFFAE4->timestamp =

            rtk_dsts_time_to_simtime_convert

            (CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFFAE4->timestamp);

        }

      } else {

        /* ... Read status and timestamp info (previous message) */

        can_tp1_msg_read_from_dsmcr(CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFFAE4);



        /* Convert timestamp */

        if (CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFFAE4->processed) {

          CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFFAE4->timestamp =

            rtk_dsts_time_to_simtime_convert

            (CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFFAE4->timestamp);

        }

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFFAE4->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_a3 = (real_T)

          CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFFAE4->processed;

        L4_MABX_B.SFunction1_o2_ob = (real_T)

          CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFFAE4->timestamp;

        L4_MABX_B.SFunction1_o3_bj = (real_T)

          CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFFAE4->deltatime;

        L4_MABX_B.SFunction1_o4_kp = (real_T)

          CANTP1_TX_M1_C2_MCRCLT_XTD_0X18FFFAE4->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;

        UInt32 i;



        /* Initialize the static message data to zero */

        for (i=0; i<8; i++ )

          CAN_Msg[i] = 0;



        /* ...... "byte1" (0|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_ff[0] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte2" (8|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_ff[1] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte3" (16|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_ff[2] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte4" (24|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_ff[3] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte5" (32|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_ff[4] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte6" (40|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_ff[5] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte7" (48|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_ff[6] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte8" (56|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_ff[7] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;

      }



      delayTime = (Float32) L4_MABX_P.Constant_Value_jq / (1700);



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M1[CANTP1_M1_C2_TX_XTD_0X18FFFAE4], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  /* End of Outputs for SubSystem: '<S898>/PropB_REAX_5_E4' */



  /* RateTransition: '<S899>/TmpRTBAtHiddenBuf_InsertedFor_PropB_REAX_5_E4_at_inport_10Inport1' */

  L4_MABX_B.TmpRTBAtHiddenBuf_InsertedFor_k = L4_MABX_B.EnablePropB_ReAX_CAN6;



  /* Outputs for Enabled SubSystem: '<S899>/PropB_REAX_5_E4' incorporates:

   *  EnablePort: '<S901>/Enable'

   */

  if (L4_MABX_B.TmpRTBAtHiddenBuf_InsertedFor_k) {

    /* S-Function (rti_commonblock): '<S901>/S-Function1' incorporates:

     *  Constant: '<S899>/Constant'

     *  Constant: '<S899>/Constant1'

     */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "PropB_REAX_5_E4" Id:419429092 */

    {

      static UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        0x00 };



      Float32 delayTime = 0.0;



      /* link this pointer to CAN_Msg for use in initialize_io_units() */

      CANTP1_PTR_M3_C2_XTD_0x18FFFAE4 = &(CAN_Msg[0]);



      /* ... perform loop-back if required */

      if (L4_MABX_P.Constant1_Value_no > 0.5) {

        /* ... updating the used tx-clientbuffer */

        can_tp1_msg_update_all( CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFFAE4->module,

          CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFFAE4->queue );



        /* ... Read status and timestamp info perform loop-back (previous message) */

        can_tp1_tx_msg_read_loopback(CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFFAE4,

          8,                           // datalen

          &(CAN_Msg[0]),

          CANTP1_RX_SPMSG_M3_C2_XTD);



        /* Convert timestamp */

        if (CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFFAE4->processed) {

          CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFFAE4->timestamp =

            rtk_dsts_time_to_simtime_convert

            (CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFFAE4->timestamp);

        }

      } else {

        /* ... Read status and timestamp info (previous message) */

        can_tp1_msg_read_from_dsmcr(CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFFAE4);



        /* Convert timestamp */

        if (CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFFAE4->processed) {

          CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFFAE4->timestamp =

            rtk_dsts_time_to_simtime_convert

            (CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFFAE4->timestamp);

        }

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFFAE4->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_nz = (real_T)

          CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFFAE4->processed;

        L4_MABX_B.SFunction1_o2_ed = (real_T)

          CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFFAE4->timestamp;

        L4_MABX_B.SFunction1_o3_o = (real_T)

          CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFFAE4->deltatime;

        L4_MABX_B.SFunction1_o4_k = (real_T)

          CANTP1_TX_M3_C2_MCRCLT_XTD_0X18FFFAE4->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;

        UInt32 i;



        /* Initialize the static message data to zero */

        for (i=0; i<8; i++ )

          CAN_Msg[i] = 0;



        /* ...... "byte1" (0|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_ff[0] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte2" (8|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_ff[1] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte3" (16|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_ff[2] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte4" (24|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_ff[3] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte5" (32|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_ff[4] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte6" (40|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_ff[5] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte7" (48|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_ff[6] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte8" (56|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_ff[7] )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;

      }



      delayTime = (Float32) L4_MABX_P.Constant_Value_pk / (1700);



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M3[CANTP1_M3_C2_TX_XTD_0X18FFFAE4], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  /* End of Outputs for SubSystem: '<S899>/PropB_REAX_5_E4' */



  /* DataTypeConversion: '<S918>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_j4 = L4_MABX_B.SID_i;



  /* DataTypeConversion: '<S918>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_f5 = L4_MABX_B.COGReference_f;



  /* DataTypeConversion: '<S918>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_m = L4_MABX_B.CourseOverGround_f;



  /* DataTypeConversion: '<S918>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_jy = L4_MABX_B.SpeedOverGround_b;



  /* DataTypeConversion: '<S888>/Data Type Conversion2' incorporates:

   *  Constant: '<S859>/enableCOGSRapidUpdateTX'

   */

  L4_MABX_B.DataTypeConversion2_k5 = L4_MABX_P.enableCOGSRapidUpdateTX_Value;



  /* Outputs for Enabled SubSystem: '<S918>/Std_COGSOGRapidUpdate_01' incorporates:

   *  EnablePort: '<S919>/Enable'

   */

  if (L4_MABX_B.DataTypeConversion2_k5) {

    /* S-Function (rti_commonblock): '<S919>/S-Function1' incorporates:

     *  Constant: '<S918>/Constant'

     *  Constant: '<S918>/Constant1'

     */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "Std_COGSOGRapidUpdate_01" Id:7 */

    {

      static UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

        0x00 };



      Float32 delayTime = 0.0;



      /* link this pointer to CAN_Msg for use in initialize_io_units() */

      CANTP1_PTR_M3_C2_STD_0x7 = &(CAN_Msg[0]);



      /* ... perform loop-back if required */

      if (L4_MABX_P.Constant1_Value_cj > 0.5) {

        /* ... updating the used tx-clientbuffer */

        can_tp1_msg_update_all( CANTP1_TX_M3_C2_MCRCLT_STD_0X7->module,

          CANTP1_TX_M3_C2_MCRCLT_STD_0X7->queue );



        /* ... Read status and timestamp info perform loop-back (previous message) */

        can_tp1_tx_msg_read_loopback(CANTP1_TX_M3_C2_MCRCLT_STD_0X7,

          8,                           // datalen

          &(CAN_Msg[0]),

          CANTP1_RX_SPMSG_M3_C2_STD);



        /* Convert timestamp */

        if (CANTP1_TX_M3_C2_MCRCLT_STD_0X7->processed) {

          CANTP1_TX_M3_C2_MCRCLT_STD_0X7->timestamp =

            rtk_dsts_time_to_simtime_convert

            (CANTP1_TX_M3_C2_MCRCLT_STD_0X7->timestamp);

        }

      } else {

        /* ... Read status and timestamp info (previous message) */

        can_tp1_msg_read_from_dsmcr(CANTP1_TX_M3_C2_MCRCLT_STD_0X7);



        /* Convert timestamp */

        if (CANTP1_TX_M3_C2_MCRCLT_STD_0X7->processed) {

          CANTP1_TX_M3_C2_MCRCLT_STD_0X7->timestamp =

            rtk_dsts_time_to_simtime_convert

            (CANTP1_TX_M3_C2_MCRCLT_STD_0X7->timestamp);

        }

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (CANTP1_TX_M3_C2_MCRCLT_STD_0X7->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_oy = (real_T)

          CANTP1_TX_M3_C2_MCRCLT_STD_0X7->processed;

        L4_MABX_B.SFunction1_o2_jm = (real_T)

          CANTP1_TX_M3_C2_MCRCLT_STD_0X7->timestamp;

        L4_MABX_B.SFunction1_o3_lx = (real_T)

          CANTP1_TX_M3_C2_MCRCLT_STD_0X7->deltatime;

        L4_MABX_B.SFunction1_o4_fwb = (real_T)

          CANTP1_TX_M3_C2_MCRCLT_STD_0X7->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;

        UInt32 i;



        /* Initialize the static message data to zero */

        for (i=0; i<8; i++ )

          CAN_Msg[i] = 0;



        /* ...... "SID" (0|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion_j4 ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "COGReference" (8|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_f5 ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "CourseOverGround" (16|16, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion2_m - ( 0 )

          ) / 0.0001 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte1;



        /* ...... "SpeedOverGround" (32|16, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion3_jy - ( 0

          ) ) / 0.01 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte1;

      }



      /* mask unused bits with '1' */

      CAN_Msg[1] |= 0xFC;

      CAN_Msg[6] |= 0xFF;

      CAN_Msg[7] |= 0xFF;

      delayTime = (Float32) L4_MABX_P.Constant_Value_b / (2000);



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0X7], 8, &(CAN_Msg[0]),

                       delayTime);

    }

  }



  /* End of Outputs for SubSystem: '<S918>/Std_COGSOGRapidUpdate_01' */



  /* DataTypeConversion: '<S889>/Data Type Conversion2' incorporates:

   *  Constant: '<S859>/enableEBC1_8B_TX'

   */

  L4_MABX_B.DataTypeConversion2_ow = L4_MABX_P.enableEBC1_8B_TX_Value;



  /* Outputs for Enabled SubSystem: '<S920>/EBC1_TX' incorporates:

   *  EnablePort: '<S921>/Enable'

   */

  if (L4_MABX_B.DataTypeConversion2_ow) {

    /* S-Function (rti_commonblock): '<S921>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "EBC1_TX" Id:418382219 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18F0018B]);



      /* Convert timestamp */

      if (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18F0018B]->processed) {

        can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18F0018B]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18F0018B]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18F0018B]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_fc = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18F0018B]->processed;

        L4_MABX_B.SFunction1_o2_km = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18F0018B]->timestamp;

        L4_MABX_B.SFunction1_o3_bb = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18F0018B]->deltatime;

        L4_MABX_B.SFunction1_o4_b = (real_T)

          can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18F0018B]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "ASREngCtrlActive" (0|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ASREngCtrlActive ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "ASRBrakeCtrlActive" (2|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ASRBrakeCtrlActive ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "AntiLockBrakingActive" (4|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.AntiLockBrakingActive ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "EBSBrakeSwitch" (6|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.EBSBrakeSwitch_j ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "BrakePedalPos" (8|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.BrakePedalPos - ( 0 ) ) /

          0.4 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "ABSOffroadSwitch" (16|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ABSOffroadSwitch ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "ASROffroadSwitch" (18|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ASROffroadSwitch ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "ASRHillHolderSwitch" (20|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ASRHillHolderSwitch ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "TractionCtrlOverrideSwitch" (22|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.TractionCtrlOverrideSwitch )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "AccelInterlockSwitch" (24|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.AccelInterlockSwitch ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "EngDerateSwitch" (26|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.EngDerateSwitch ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "EngAuxShutdownSwitch" (28|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.EngAuxShutdownSwitch ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "RemoteAccelEnableSwitch" (30|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.RemoteAccelEnableSwitch ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "EngRetarderSelection" (32|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.EngRetarderSelection - ( 0 )

          ) / 0.4 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "ABSFullyOperational" (40|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ABSFullyOperational ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "EBSRedWarningSignal" (42|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.EBSRedWarningSignal ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "ABS_EBSAmberWarningSignal" (44|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ABS_EBSAmberWarningSignal )

          + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "ATC_ASRInformationSignal" (46|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ATC_ASRInformationSignal ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "SrcAddrssOfCtrllngDvcFrBrkCntrl" (48|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32)

          (( L4_MABX_B.SrcAddrssOfCtrllngDvcFrBrkCntrl ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "HaltBrakeSwitch" (58|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.HaltBrakeSwitch ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 2;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "TrailerABSStatus" (60|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.TrailerABSStatus ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 4;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "TrctrMntdTrilerABSWarningSignal" (62|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32)

          (( L4_MABX_B.TrctrMntdTrilerABSWarningSignal ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Sgn.UnsignedSgn = ((UInt32)CAN_Sgn.UnsignedSgn) << 6;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;

      }



      /* mask unused bits with '1' */

      CAN_Msg[7] |= 0x03;



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18F0018B], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  /* End of Outputs for SubSystem: '<S920>/EBC1_TX' */



  /* End of Outputs for SubSystem: '<S855>/CAN_TX_100ms' */



  /* DiscretePulseGenerator: '<S1083>/Flash' */

  L4_MABX_B.Flash = (L4_MABX_DW.clockTickCounter_k < L4_MABX_P.Flash_Duty) &&

    (L4_MABX_DW.clockTickCounter_k >= 0) ? L4_MABX_P.Flash_Amp : 0.0;

  if (L4_MABX_DW.clockTickCounter_k >= L4_MABX_P.Flash_Period - 1.0) {

    L4_MABX_DW.clockTickCounter_k = 0;

  } else {

    L4_MABX_DW.clockTickCounter_k++;

  }



  /* End of DiscretePulseGenerator: '<S1083>/Flash' */

  /* user code (Output function Trailer for TID3) */



  /* XCP Data Capture block: <Root>/RTIEthXCP Data Capture */

  /* EventChannel: 0 */

  if (tid == 0) {

    DSXCP_service(0);

  }



  /* If subsystem generates rate grouping Output functions,

   * when tid is used in Output function for one rate,

   * all Output functions include tid as a local variable.

   * As result, some Output functions may have unused tid.

   */

  UNUSED_PARAMETER(tid);

}



/* Model update function for TID3 */

void L4_MABX_update3(void)             /* Sample time: [0.1s, 0.0s] */

{

  /* Update for Atomic SubSystem: '<S855>/CAN_TX_100ms' */



  /* Update for Enabled SubSystem: '<S892>/Rolling_15_counter' incorporates:

   *  EnablePort: '<S934>/Enable'

   */

  if (L4_MABX_B.TmpRTBAtHiddenBuf_InsertedFor_R) {

    /* Update for UnitDelay: '<S934>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE = L4_MABX_B.FixPtSwitch;

  }



  /* End of Update for SubSystem: '<S892>/Rolling_15_counter' */



  /* End of Update for SubSystem: '<S855>/CAN_TX_100ms' */



  /* Update for RateTransition: '<S1083>/TmpRTBAtFlashOutport1' */

  L4_MABX_DW.TmpRTBAtFlashOutport1_Buffer0 = L4_MABX_B.Flash;

}



/* Model output function for TID4 */

void L4_MABX_output4(void)             /* Sample time: [0.25s, 0.0s] */

{

  int_T tid = 4;



  /* user code (Output function Trailer for TID4) */



  /* XCP Data Capture block: <Root>/RTIEthXCP Data Capture */

  /* EventChannel: 0 */

  if (tid == 0) {

    DSXCP_service(0);

  }



  /* If subsystem generates rate grouping Output functions,

   * when tid is used in Output function for one rate,

   * all Output functions include tid as a local variable.

   * As result, some Output functions may have unused tid.

   */

  UNUSED_PARAMETER(tid);

}



/* Model update function for TID4 */

void L4_MABX_update4(void)             /* Sample time: [0.25s, 0.0s] */

{

  /* (no update code required) */

}



/* Model output function for TID5 */

void L4_MABX_output5(void)             /* Sample time: [0.5s, 0.0s] */

{

  int_T tid = 5;

  boolean_T zcEvent;

  uint32_T q0;

  uint32_T qY;



  /* S-Function (rti_commonblock): '<S28>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* dSPACE RTICAN Status block */

  /* ... read status variables of the CAN microcontroller */

  {

    UInt32 loop_counter, memory, j;

    for (j=0;j<=9;j++) {

      rtican_type1_tq_error[0][6] = can_tp1_service_read

        (can_type1_service_M1_C1[j]);

      loop_counter = 0;

      while ((rtican_type1_tq_error[0][6] = can_tp1_service_request

              (can_type1_service_M1_C1[j]))== DSMCOM_BUFFER_OVERFLOW) {

        loop_counter++;

        if (loop_counter > MAX_LOOP) {

          memory = rtican_type1_error_level;

          rtican_type1_error_level = 1;

          rtican_type1_tq_err_sig(0, 6);

          rtican_type1_error_level = memory;

          break;

        }

      }



      if (j==CANTP1_M1_C1_RXLost) {

        rtican_type1_tq_error[0][6] = can_tp1_service_read

          (can_type1_service_M1_C1[CANTP1_M1_C1_DataLost]);

        loop_counter = 0;

        while ((rtican_type1_tq_error[0][6] = can_tp1_service_request

                (can_type1_service_M1_C1[CANTP1_M1_C1_DataLost]))==

               DSMCOM_BUFFER_OVERFLOW) {

          loop_counter++;

          if (loop_counter > MAX_LOOP) {

            memory = rtican_type1_error_level;

            rtican_type1_error_level = 1;

            rtican_type1_tq_err_sig(0, 6);

            rtican_type1_error_level = memory;

            break;

          }

        }

      }

    }



    L4_MABX_B.SFunction1_o1_kx = (UInt32)

      can_type1_service_M1_C1[CANTP1_M1_C1_Status]->data0;

    DIAG_CAN1_Count_Stuff_Errors = (UInt32)

      can_type1_service_M1_C1[CANTP1_M1_C1_StuffErrors]->data0;

    DIAG_CAN1_Count_Format_Errors = (UInt32)

      can_type1_service_M1_C1[CANTP1_M1_C1_FormatErrors]->data0;

    DIAG_CAN1_Count_Ack_Errors = (UInt32)

      can_type1_service_M1_C1[CANTP1_M1_C1_AckErrors]->data0;

    DIAG_CAN1_Count_Bit0_Errors = (UInt32)

      can_type1_service_M1_C1[CANTP1_M1_C1_Bit0Errors]->data0;

    DIAG_CAN1_Count_Bit1_Errors = (UInt32)

      can_type1_service_M1_C1[CANTP1_M1_C1_Bit1Errors]->data0;

    DIAG_CAN1_Count_CRC_Errors = (UInt32)

      can_type1_service_M1_C1[CANTP1_M1_C1_CRCErrors]->data0;

    DIAG_CAN1_Count_RX_Lost = (UInt32)

      (can_type1_service_M1_C1[CANTP1_M1_C1_RXLost]->data0 +

       can_type1_service_M1_C1[CANTP1_M1_C1_DataLost]->data0);

    DIAG_CAN1_Count_RX_OK = (UInt32) can_type1_service_M1_C1[CANTP1_M1_C1_RXOK

      ]->data0;

    DIAG_CAN1_Count_TX_OK = (UInt32) can_type1_service_M1_C1[CANTP1_M1_C1_TXOK

      ]->data0;

  }



  /* DataTypeConversion: '<S1>/Data Type Conversion' */

  DIAG_CAN1_Status = (ENUM_CAN_STATUS_DIAG_T)safe_cast_to_ENUM_CAN_STATUS_DI

    ((int32_T)L4_MABX_B.SFunction1_o1_kx);



  /* RelationalOperator: '<S22>/Operator' incorporates:

   *  Constant: '<S1>/Constant'

   */

  L4_MABX_B.Operator_euc = (L4_MABX_P.Constant_Value_c == DIAG_CAN1_Status);



  /* Outputs for Enabled SubSystem: '<S1>/BUS_OFF_RECOVERY_1' incorporates:

   *  EnablePort: '<S11>/Enable'

   */

  if (L4_MABX_B.Operator_euc) {

    /* Reshape: '<S30>/Reshape' incorporates:

     *  Constant: '<S30>/Constant'

     */

    L4_MABX_B.Reshape_g[0] = L4_MABX_P.Repeating_Sequence_Stair_OutV_l[0];

    L4_MABX_B.Reshape_g[1] = L4_MABX_P.Repeating_Sequence_Stair_OutV_l[1];



    /* UnitDelay: '<S30>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_h4 = L4_MABX_DW.Unit_Delay_DSTATE_f1;



    /* UnitDelay: '<S31>/Unit Delay' */

    L4_MABX_B.UnitDelay_f4 = L4_MABX_DW.UnitDelay_DSTATE_j1;



    /* Switch: '<S34>/Switch1' incorporates:

     *  Constant: '<S31>/E'

     *  Constant: '<S31>/IV'

     *  Switch: '<S33>/Switch1'

     */

    if (L4_MABX_B.Unit_Delay_h4) {

      L4_MABX_B.Switch1_o = L4_MABX_P.IV_Value_m;

    } else {

      if (L4_MABX_P.E_Value) {

        /* Sum: '<S31>/Subtract' incorporates:

         *  Constant: '<S31>/Constant'

         *  Switch: '<S33>/Switch1'

         */

        q0 = L4_MABX_P.Constant_Value_jc;

        qY = q0 + L4_MABX_B.UnitDelay_f4;

        if (qY < q0) {

          qY = MAX_uint32_T;

        }



        L4_MABX_B.Subtract_ot = qY;



        /* End of Sum: '<S31>/Subtract' */



        /* Switch: '<S33>/Switch1' */

        L4_MABX_B.Switch1_az = L4_MABX_B.Subtract_ot;

      } else {

        /* Switch: '<S33>/Switch1' */

        L4_MABX_B.Switch1_az = L4_MABX_B.UnitDelay_f4;

      }



      L4_MABX_B.Switch1_o = L4_MABX_B.Switch1_az;

    }



    /* End of Switch: '<S34>/Switch1' */



    /* Selector: '<S30>/Selector' */

    L4_MABX_B.Selector_d = L4_MABX_B.Reshape_g[(int32_T)L4_MABX_B.Switch1_o - 1];



    /* Outputs for Triggered SubSystem: '<S11>/CAN_TYPE1_BOR_M1_C1' incorporates:

     *  TriggerPort: '<S29>/Trigger'

     */

    zcEvent = (((L4_MABX_PrevZCX.CAN_TYPE1_BOR_M1_C1_Trig_ZCE == POS_ZCSIG) !=

                (int32_T)L4_MABX_B.Selector_d) &&

               (L4_MABX_PrevZCX.CAN_TYPE1_BOR_M1_C1_Trig_ZCE !=

                UNINITIALIZED_ZCSIG));

    if (zcEvent) {

      /* S-Function (rti_commonblock): '<S29>/S-Function1' */

      /* This comment workarounds a code generation problem */



      /* dSPACE RTICAN Bus Off Recovery block */

      /* ... Perform software-reset of the CAN microcontroller */

      {

        UInt32 loop_counter, memory;

        loop_counter = 0;

        while ((rtican_type1_tq_error[0][0] = can_tp1_channel_BOff_return

                (can_type1_channel_M1_C1)) == DSMCOM_BUFFER_OVERFLOW) {

          loop_counter++;

          if (loop_counter > MAX_LOOP) {

            memory = rtican_type1_error_level;

            rtican_type1_error_level = 1;

            rtican_type1_tq_err_sig(0, 0);

            rtican_type1_error_level = memory;

            break;

          }

        }



        while ((rtican_type1_tq_error[0][0] = can_tp1_channel_all_wakeup

                (can_type1_channel_M1_C1)) == DSMCOM_BUFFER_OVERFLOW) {

          loop_counter++;

          if (loop_counter > MAX_LOOP) {

            memory = rtican_type1_error_level;

            rtican_type1_error_level = 1;

            rtican_type1_tq_err_sig(0, 0);

            rtican_type1_error_level = memory;

            break;

          }

        }

      }

    }



    L4_MABX_PrevZCX.CAN_TYPE1_BOR_M1_C1_Trig_ZCE = L4_MABX_B.Selector_d;



    /* End of Outputs for SubSystem: '<S11>/CAN_TYPE1_BOR_M1_C1' */



    /* RelationalOperator: '<S32>/Operator' */

    L4_MABX_B.Operator_f5 = (L4_MABX_B.Switch1_o == L4_MABX_ConstB.Width_p);

  }



  /* End of Outputs for SubSystem: '<S1>/BUS_OFF_RECOVERY_1' */



  /* S-Function (rti_commonblock): '<S20>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* dSPACE RTICAN Status block */

  /* ... read status variables of the CAN microcontroller */

  {

    UInt32 loop_counter, memory, j;

    for (j=0;j<=9;j++) {

      rtican_type1_tq_error[2][6] = can_tp1_service_read

        (can_type1_service_M3_C1[j]);

      loop_counter = 0;

      while ((rtican_type1_tq_error[2][6] = can_tp1_service_request

              (can_type1_service_M3_C1[j]))== DSMCOM_BUFFER_OVERFLOW) {

        loop_counter++;

        if (loop_counter > MAX_LOOP) {

          memory = rtican_type1_error_level;

          rtican_type1_error_level = 1;

          rtican_type1_tq_err_sig(2, 6);

          rtican_type1_error_level = memory;

          break;

        }

      }



      if (j==CANTP1_M3_C1_RXLost) {

        rtican_type1_tq_error[2][6] = can_tp1_service_read

          (can_type1_service_M3_C1[CANTP1_M3_C1_DataLost]);

        loop_counter = 0;

        while ((rtican_type1_tq_error[2][6] = can_tp1_service_request

                (can_type1_service_M3_C1[CANTP1_M3_C1_DataLost]))==

               DSMCOM_BUFFER_OVERFLOW) {

          loop_counter++;

          if (loop_counter > MAX_LOOP) {

            memory = rtican_type1_error_level;

            rtican_type1_error_level = 1;

            rtican_type1_tq_err_sig(2, 6);

            rtican_type1_error_level = memory;

            break;

          }

        }

      }

    }



    L4_MABX_B.SFunction1_o1_g3j = (UInt32)

      can_type1_service_M3_C1[CANTP1_M3_C1_Status]->data0;

    DIAG_CAN5_Count_Stuff_Errors = (UInt32)

      can_type1_service_M3_C1[CANTP1_M3_C1_StuffErrors]->data0;

    DIAG_CAN5_Count_Format_Errors = (UInt32)

      can_type1_service_M3_C1[CANTP1_M3_C1_FormatErrors]->data0;

    DIAG_CAN5_Count_Ack_Errors = (UInt32)

      can_type1_service_M3_C1[CANTP1_M3_C1_AckErrors]->data0;

    DIAG_CAN5_Count_Bit0_Errors = (UInt32)

      can_type1_service_M3_C1[CANTP1_M3_C1_Bit0Errors]->data0;

    DIAG_CAN5_Count_Bit1_Errors = (UInt32)

      can_type1_service_M3_C1[CANTP1_M3_C1_Bit1Errors]->data0;

    DIAG_CAN5_Count_CRC_Errors = (UInt32)

      can_type1_service_M3_C1[CANTP1_M3_C1_CRCErrors]->data0;

    DIAG_CAN5_Count_RX_Lost = (UInt32)

      (can_type1_service_M3_C1[CANTP1_M3_C1_RXLost]->data0 +

       can_type1_service_M3_C1[CANTP1_M3_C1_DataLost]->data0);

    DIAG_CAN5_Count_RX_OK = (UInt32) can_type1_service_M3_C1[CANTP1_M3_C1_RXOK

      ]->data0;

    DIAG_CAN5_Count_TX_OK = (UInt32) can_type1_service_M3_C1[CANTP1_M3_C1_TXOK

      ]->data0;

  }



  /* DataTypeConversion: '<S1>/Data Type Conversion5' */

  DIAG_CAN5_Status = (ENUM_CAN_STATUS_DIAG_T)safe_cast_to_ENUM_CAN_STATUS_DI

    ((int32_T)L4_MABX_B.SFunction1_o1_g3j);



  /* RelationalOperator: '<S26>/Operator' incorporates:

   *  Constant: '<S1>/Constant4'

   */

  L4_MABX_B.Operator_msz = (L4_MABX_P.Constant4_Value_np == DIAG_CAN5_Status);



  /* Outputs for Enabled SubSystem: '<S1>/BUS_OFF_RECOVERY_5' incorporates:

   *  EnablePort: '<S15>/Enable'

   */

  if (L4_MABX_B.Operator_msz) {

    /* Reshape: '<S54>/Reshape' incorporates:

     *  Constant: '<S54>/Constant'

     */

    L4_MABX_B.Reshape_a[0] = L4_MABX_P.Repeating_Sequence_Stair_OutV_j[0];

    L4_MABX_B.Reshape_a[1] = L4_MABX_P.Repeating_Sequence_Stair_OutV_j[1];



    /* UnitDelay: '<S54>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_p1 = L4_MABX_DW.Unit_Delay_DSTATE_i5;



    /* UnitDelay: '<S55>/Unit Delay' */

    L4_MABX_B.UnitDelay_j = L4_MABX_DW.UnitDelay_DSTATE_p;



    /* Switch: '<S58>/Switch1' incorporates:

     *  Constant: '<S55>/E'

     *  Constant: '<S55>/IV'

     *  Switch: '<S57>/Switch1'

     */

    if (L4_MABX_B.Unit_Delay_p1) {

      L4_MABX_B.Switch1_k = L4_MABX_P.IV_Value_h;

    } else {

      if (L4_MABX_P.E_Value_db) {

        /* Sum: '<S55>/Subtract' incorporates:

         *  Constant: '<S55>/Constant'

         *  Switch: '<S57>/Switch1'

         */

        q0 = L4_MABX_P.Constant_Value_jg;

        qY = q0 + L4_MABX_B.UnitDelay_j;

        if (qY < q0) {

          qY = MAX_uint32_T;

        }



        L4_MABX_B.Subtract_m = qY;



        /* End of Sum: '<S55>/Subtract' */



        /* Switch: '<S57>/Switch1' */

        L4_MABX_B.Switch1_l = L4_MABX_B.Subtract_m;

      } else {

        /* Switch: '<S57>/Switch1' */

        L4_MABX_B.Switch1_l = L4_MABX_B.UnitDelay_j;

      }



      L4_MABX_B.Switch1_k = L4_MABX_B.Switch1_l;

    }



    /* End of Switch: '<S58>/Switch1' */



    /* Selector: '<S54>/Selector' */

    L4_MABX_B.Selector_p = L4_MABX_B.Reshape_a[(int32_T)L4_MABX_B.Switch1_k - 1];



    /* Outputs for Triggered SubSystem: '<S15>/CAN_TYPE1_BOR_M3_C1' incorporates:

     *  TriggerPort: '<S53>/Trigger'

     */

    zcEvent = (((L4_MABX_PrevZCX.CAN_TYPE1_BOR_M3_C1_Trig_ZCE == POS_ZCSIG) !=

                (int32_T)L4_MABX_B.Selector_p) &&

               (L4_MABX_PrevZCX.CAN_TYPE1_BOR_M3_C1_Trig_ZCE !=

                UNINITIALIZED_ZCSIG));

    if (zcEvent) {

      /* S-Function (rti_commonblock): '<S53>/S-Function1' */

      /* This comment workarounds a code generation problem */



      /* dSPACE RTICAN Bus Off Recovery block */

      /* ... Perform software-reset of the CAN microcontroller */

      {

        UInt32 loop_counter, memory;

        loop_counter = 0;

        while ((rtican_type1_tq_error[2][0] = can_tp1_channel_BOff_return

                (can_type1_channel_M3_C1)) == DSMCOM_BUFFER_OVERFLOW) {

          loop_counter++;

          if (loop_counter > MAX_LOOP) {

            memory = rtican_type1_error_level;

            rtican_type1_error_level = 1;

            rtican_type1_tq_err_sig(2, 0);

            rtican_type1_error_level = memory;

            break;

          }

        }



        while ((rtican_type1_tq_error[2][0] = can_tp1_channel_all_wakeup

                (can_type1_channel_M3_C1)) == DSMCOM_BUFFER_OVERFLOW) {

          loop_counter++;

          if (loop_counter > MAX_LOOP) {

            memory = rtican_type1_error_level;

            rtican_type1_error_level = 1;

            rtican_type1_tq_err_sig(2, 0);

            rtican_type1_error_level = memory;

            break;

          }

        }

      }

    }



    L4_MABX_PrevZCX.CAN_TYPE1_BOR_M3_C1_Trig_ZCE = L4_MABX_B.Selector_p;



    /* End of Outputs for SubSystem: '<S15>/CAN_TYPE1_BOR_M3_C1' */



    /* RelationalOperator: '<S56>/Operator' */

    L4_MABX_B.Operator_ho = (L4_MABX_B.Switch1_k == L4_MABX_ConstB.Width_a);

  }



  /* End of Outputs for SubSystem: '<S1>/BUS_OFF_RECOVERY_5' */



  /* S-Function (rti_commonblock): '<S21>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* dSPACE RTICAN Status block */

  /* ... read status variables of the CAN microcontroller */

  {

    UInt32 loop_counter, memory, j;

    for (j=0;j<=9;j++) {

      rtican_type1_tq_error[2][6] = can_tp1_service_read

        (can_type1_service_M3_C2[j]);

      loop_counter = 0;

      while ((rtican_type1_tq_error[2][6] = can_tp1_service_request

              (can_type1_service_M3_C2[j]))== DSMCOM_BUFFER_OVERFLOW) {

        loop_counter++;

        if (loop_counter > MAX_LOOP) {

          memory = rtican_type1_error_level;

          rtican_type1_error_level = 1;

          rtican_type1_tq_err_sig(2, 6);

          rtican_type1_error_level = memory;

          break;

        }

      }



      if (j==CANTP1_M3_C2_RXLost) {

        rtican_type1_tq_error[2][6] = can_tp1_service_read

          (can_type1_service_M3_C2[CANTP1_M3_C2_DataLost]);

        loop_counter = 0;

        while ((rtican_type1_tq_error[2][6] = can_tp1_service_request

                (can_type1_service_M3_C2[CANTP1_M3_C2_DataLost]))==

               DSMCOM_BUFFER_OVERFLOW) {

          loop_counter++;

          if (loop_counter > MAX_LOOP) {

            memory = rtican_type1_error_level;

            rtican_type1_error_level = 1;

            rtican_type1_tq_err_sig(2, 6);

            rtican_type1_error_level = memory;

            break;

          }

        }

      }

    }



    L4_MABX_B.SFunction1_o1_ar5 = (UInt32)

      can_type1_service_M3_C2[CANTP1_M3_C2_Status]->data0;

    DIAG_CAN6_Count_Stuff_Errors = (UInt32)

      can_type1_service_M3_C2[CANTP1_M3_C2_StuffErrors]->data0;

    DIAG_CAN6_Count_Format_Errors = (UInt32)

      can_type1_service_M3_C2[CANTP1_M3_C2_FormatErrors]->data0;

    DIAG_CAN6_Count_Ack_Errors = (UInt32)

      can_type1_service_M3_C2[CANTP1_M3_C2_AckErrors]->data0;

    DIAG_CAN6_Count_Bit0_Errors = (UInt32)

      can_type1_service_M3_C2[CANTP1_M3_C2_Bit0Errors]->data0;

    DIAG_CAN6_Count_Bit1_Errors = (UInt32)

      can_type1_service_M3_C2[CANTP1_M3_C2_Bit1Errors]->data0;

    DIAG_CAN6_Count_CRC_Errors = (UInt32)

      can_type1_service_M3_C2[CANTP1_M3_C2_CRCErrors]->data0;

    DIAG_CAN6_Count_RX_Lost = (UInt32)

      (can_type1_service_M3_C2[CANTP1_M3_C2_RXLost]->data0 +

       can_type1_service_M3_C2[CANTP1_M3_C2_DataLost]->data0);

    DIAG_CAN6_Count_RX_OK = (UInt32) can_type1_service_M3_C2[CANTP1_M3_C2_RXOK

      ]->data0;

    DIAG_CAN6_Count_TX_OK = (UInt32) can_type1_service_M3_C2[CANTP1_M3_C2_TXOK

      ]->data0;

  }



  /* DataTypeConversion: '<S1>/Data Type Conversion4' */

  DIAG_CAN6_Status = (ENUM_CAN_STATUS_DIAG_T)safe_cast_to_ENUM_CAN_STATUS_DI

    ((int32_T)L4_MABX_B.SFunction1_o1_ar5);



  /* RelationalOperator: '<S27>/Operator' incorporates:

   *  Constant: '<S1>/Constant5'

   */

  L4_MABX_B.Operator_fv = (L4_MABX_P.Constant5_Value_m == DIAG_CAN6_Status);



  /* Outputs for Enabled SubSystem: '<S1>/BUS_OFF_RECOVERY_6' incorporates:

   *  EnablePort: '<S16>/Enable'

   */

  if (L4_MABX_B.Operator_fv) {

    /* Reshape: '<S60>/Reshape' incorporates:

     *  Constant: '<S60>/Constant'

     */

    L4_MABX_B.Reshape_j[0] = L4_MABX_P.Repeating_Sequence_Stair_OutV_e[0];

    L4_MABX_B.Reshape_j[1] = L4_MABX_P.Repeating_Sequence_Stair_OutV_e[1];



    /* UnitDelay: '<S60>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_mw = L4_MABX_DW.Unit_Delay_DSTATE_l5;



    /* UnitDelay: '<S61>/Unit Delay' */

    L4_MABX_B.UnitDelay_av = L4_MABX_DW.UnitDelay_DSTATE_dr;



    /* Switch: '<S64>/Switch1' incorporates:

     *  Constant: '<S61>/E'

     *  Constant: '<S61>/IV'

     *  Switch: '<S63>/Switch1'

     */

    if (L4_MABX_B.Unit_Delay_mw) {

      L4_MABX_B.Switch1_h = L4_MABX_P.IV_Value_ey;

    } else {

      if (L4_MABX_P.E_Value_c) {

        /* Sum: '<S61>/Subtract' incorporates:

         *  Constant: '<S61>/Constant'

         *  Switch: '<S63>/Switch1'

         */

        q0 = L4_MABX_P.Constant_Value_iu;

        qY = q0 + L4_MABX_B.UnitDelay_av;

        if (qY < q0) {

          qY = MAX_uint32_T;

        }



        L4_MABX_B.Subtract_fc = qY;



        /* End of Sum: '<S61>/Subtract' */



        /* Switch: '<S63>/Switch1' */

        L4_MABX_B.Switch1_bs = L4_MABX_B.Subtract_fc;

      } else {

        /* Switch: '<S63>/Switch1' */

        L4_MABX_B.Switch1_bs = L4_MABX_B.UnitDelay_av;

      }



      L4_MABX_B.Switch1_h = L4_MABX_B.Switch1_bs;

    }



    /* End of Switch: '<S64>/Switch1' */



    /* Selector: '<S60>/Selector' */

    L4_MABX_B.Selector_h = L4_MABX_B.Reshape_j[(int32_T)L4_MABX_B.Switch1_h - 1];



    /* Outputs for Triggered SubSystem: '<S16>/CAN_TYPE1_BOR_M3_C2' incorporates:

     *  TriggerPort: '<S59>/Trigger'

     */

    zcEvent = (((L4_MABX_PrevZCX.CAN_TYPE1_BOR_M3_C2_Trig_ZCE == POS_ZCSIG) !=

                (int32_T)L4_MABX_B.Selector_h) &&

               (L4_MABX_PrevZCX.CAN_TYPE1_BOR_M3_C2_Trig_ZCE !=

                UNINITIALIZED_ZCSIG));

    if (zcEvent) {

      /* S-Function (rti_commonblock): '<S59>/S-Function1' */

      /* This comment workarounds a code generation problem */



      /* dSPACE RTICAN Bus Off Recovery block */

      /* ... Perform software-reset of the CAN microcontroller */

      {

        UInt32 loop_counter, memory;

        loop_counter = 0;

        while ((rtican_type1_tq_error[2][0] = can_tp1_channel_BOff_return

                (can_type1_channel_M3_C2)) == DSMCOM_BUFFER_OVERFLOW) {

          loop_counter++;

          if (loop_counter > MAX_LOOP) {

            memory = rtican_type1_error_level;

            rtican_type1_error_level = 1;

            rtican_type1_tq_err_sig(2, 0);

            rtican_type1_error_level = memory;

            break;

          }

        }



        while ((rtican_type1_tq_error[2][0] = can_tp1_channel_all_wakeup

                (can_type1_channel_M3_C2)) == DSMCOM_BUFFER_OVERFLOW) {

          loop_counter++;

          if (loop_counter > MAX_LOOP) {

            memory = rtican_type1_error_level;

            rtican_type1_error_level = 1;

            rtican_type1_tq_err_sig(2, 0);

            rtican_type1_error_level = memory;

            break;

          }

        }

      }

    }



    L4_MABX_PrevZCX.CAN_TYPE1_BOR_M3_C2_Trig_ZCE = L4_MABX_B.Selector_h;



    /* End of Outputs for SubSystem: '<S16>/CAN_TYPE1_BOR_M3_C2' */



    /* RelationalOperator: '<S62>/Operator' */

    L4_MABX_B.Operator_bg = (L4_MABX_B.Switch1_h == L4_MABX_ConstB.Width);

  }



  /* End of Outputs for SubSystem: '<S1>/BUS_OFF_RECOVERY_6' */



  /* S-Function (rti_commonblock): '<S18>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* dSPACE RTICAN Status block */

  /* ... read status variables of the CAN microcontroller */

  {

    UInt32 loop_counter, memory, j;

    for (j=0;j<=9;j++) {

      rtican_type1_tq_error[1][6] = can_tp1_service_read

        (can_type1_service_M2_C1[j]);

      loop_counter = 0;

      while ((rtican_type1_tq_error[1][6] = can_tp1_service_request

              (can_type1_service_M2_C1[j]))== DSMCOM_BUFFER_OVERFLOW) {

        loop_counter++;

        if (loop_counter > MAX_LOOP) {

          memory = rtican_type1_error_level;

          rtican_type1_error_level = 1;

          rtican_type1_tq_err_sig(1, 6);

          rtican_type1_error_level = memory;

          break;

        }

      }



      if (j==CANTP1_M2_C1_RXLost) {

        rtican_type1_tq_error[1][6] = can_tp1_service_read

          (can_type1_service_M2_C1[CANTP1_M2_C1_DataLost]);

        loop_counter = 0;

        while ((rtican_type1_tq_error[1][6] = can_tp1_service_request

                (can_type1_service_M2_C1[CANTP1_M2_C1_DataLost]))==

               DSMCOM_BUFFER_OVERFLOW) {

          loop_counter++;

          if (loop_counter > MAX_LOOP) {

            memory = rtican_type1_error_level;

            rtican_type1_error_level = 1;

            rtican_type1_tq_err_sig(1, 6);

            rtican_type1_error_level = memory;

            break;

          }

        }

      }

    }



    L4_MABX_B.SFunction1_o1_h4 = (UInt32)

      can_type1_service_M2_C1[CANTP1_M2_C1_Status]->data0;

    DIAG_CAN3_Count_Stuff_Errors = (UInt32)

      can_type1_service_M2_C1[CANTP1_M2_C1_StuffErrors]->data0;

    DIAG_CAN3_Count_Format_Errors = (UInt32)

      can_type1_service_M2_C1[CANTP1_M2_C1_FormatErrors]->data0;

    DIAG_CAN3_Count_Ack_Errors = (UInt32)

      can_type1_service_M2_C1[CANTP1_M2_C1_AckErrors]->data0;

    DIAG_CAN3_Count_Bit0_Errors = (UInt32)

      can_type1_service_M2_C1[CANTP1_M2_C1_Bit0Errors]->data0;

    DIAG_CAN3_Count_Bit1_Errors = (UInt32)

      can_type1_service_M2_C1[CANTP1_M2_C1_Bit1Errors]->data0;

    DIAG_CAN3_Count_CRC_Errors = (UInt32)

      can_type1_service_M2_C1[CANTP1_M2_C1_CRCErrors]->data0;

    DIAG_CAN3_Count_RX_Lost = (UInt32)

      (can_type1_service_M2_C1[CANTP1_M2_C1_RXLost]->data0 +

       can_type1_service_M2_C1[CANTP1_M2_C1_DataLost]->data0);

    DIAG_CAN3_Count_RX_OK = (UInt32) can_type1_service_M2_C1[CANTP1_M2_C1_RXOK

      ]->data0;

    DIAG_CAN3_Count_TX_OK = (UInt32) can_type1_service_M2_C1[CANTP1_M2_C1_TXOK

      ]->data0;

  }



  /* DataTypeConversion: '<S1>/Data Type Conversion3' */

  DIAG_CAN3_Status = (ENUM_CAN_STATUS_DIAG_T)safe_cast_to_ENUM_CAN_STATUS_DI

    ((int32_T)L4_MABX_B.SFunction1_o1_h4);



  /* RelationalOperator: '<S24>/Operator' incorporates:

   *  Constant: '<S1>/Constant1'

   */

  L4_MABX_B.Operator_bsh = (L4_MABX_P.Constant1_Value_c0 == DIAG_CAN3_Status);



  /* Outputs for Enabled SubSystem: '<S1>/BUS_OFF_RECOVERY_3' incorporates:

   *  EnablePort: '<S13>/Enable'

   */

  if (L4_MABX_B.Operator_bsh) {

    /* Reshape: '<S42>/Reshape' incorporates:

     *  Constant: '<S42>/Constant'

     */

    L4_MABX_B.Reshape_iq[0] = L4_MABX_P.Repeating_Sequence_Stair_OutV_o[0];

    L4_MABX_B.Reshape_iq[1] = L4_MABX_P.Repeating_Sequence_Stair_OutV_o[1];



    /* UnitDelay: '<S42>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_m0 = L4_MABX_DW.Unit_Delay_DSTATE_h41;



    /* UnitDelay: '<S43>/Unit Delay' */

    L4_MABX_B.UnitDelay_d = L4_MABX_DW.UnitDelay_DSTATE_dr4;



    /* Switch: '<S46>/Switch1' incorporates:

     *  Constant: '<S43>/E'

     *  Constant: '<S43>/IV'

     *  Switch: '<S45>/Switch1'

     */

    if (L4_MABX_B.Unit_Delay_m0) {

      L4_MABX_B.Switch1_k4 = L4_MABX_P.IV_Value_b;

    } else {

      if (L4_MABX_P.E_Value_d) {

        /* Sum: '<S43>/Subtract' incorporates:

         *  Constant: '<S43>/Constant'

         *  Switch: '<S45>/Switch1'

         */

        q0 = L4_MABX_P.Constant_Value_h3;

        qY = q0 + L4_MABX_B.UnitDelay_d;

        if (qY < q0) {

          qY = MAX_uint32_T;

        }



        L4_MABX_B.Subtract_h = qY;



        /* End of Sum: '<S43>/Subtract' */



        /* Switch: '<S45>/Switch1' */

        L4_MABX_B.Switch1_fr = L4_MABX_B.Subtract_h;

      } else {

        /* Switch: '<S45>/Switch1' */

        L4_MABX_B.Switch1_fr = L4_MABX_B.UnitDelay_d;

      }



      L4_MABX_B.Switch1_k4 = L4_MABX_B.Switch1_fr;

    }



    /* End of Switch: '<S46>/Switch1' */



    /* Selector: '<S42>/Selector' */

    L4_MABX_B.Selector_g = L4_MABX_B.Reshape_iq[(int32_T)L4_MABX_B.Switch1_k4 -

      1];



    /* Outputs for Triggered SubSystem: '<S13>/CAN_TYPE1_BOR_M2_C1' incorporates:

     *  TriggerPort: '<S41>/Trigger'

     */

    zcEvent = (((L4_MABX_PrevZCX.CAN_TYPE1_BOR_M2_C1_Trig_ZCE == POS_ZCSIG) !=

                (int32_T)L4_MABX_B.Selector_g) &&

               (L4_MABX_PrevZCX.CAN_TYPE1_BOR_M2_C1_Trig_ZCE !=

                UNINITIALIZED_ZCSIG));

    if (zcEvent) {

      /* S-Function (rti_commonblock): '<S41>/S-Function1' */

      /* This comment workarounds a code generation problem */



      /* dSPACE RTICAN Bus Off Recovery block */

      /* ... Perform software-reset of the CAN microcontroller */

      {

        UInt32 loop_counter, memory;

        loop_counter = 0;

        while ((rtican_type1_tq_error[1][0] = can_tp1_channel_BOff_return

                (can_type1_channel_M2_C1)) == DSMCOM_BUFFER_OVERFLOW) {

          loop_counter++;

          if (loop_counter > MAX_LOOP) {

            memory = rtican_type1_error_level;

            rtican_type1_error_level = 1;

            rtican_type1_tq_err_sig(1, 0);

            rtican_type1_error_level = memory;

            break;

          }

        }



        while ((rtican_type1_tq_error[1][0] = can_tp1_channel_all_wakeup

                (can_type1_channel_M2_C1)) == DSMCOM_BUFFER_OVERFLOW) {

          loop_counter++;

          if (loop_counter > MAX_LOOP) {

            memory = rtican_type1_error_level;

            rtican_type1_error_level = 1;

            rtican_type1_tq_err_sig(1, 0);

            rtican_type1_error_level = memory;

            break;

          }

        }

      }

    }



    L4_MABX_PrevZCX.CAN_TYPE1_BOR_M2_C1_Trig_ZCE = L4_MABX_B.Selector_g;



    /* End of Outputs for SubSystem: '<S13>/CAN_TYPE1_BOR_M2_C1' */



    /* RelationalOperator: '<S44>/Operator' */

    L4_MABX_B.Operator_dh = (L4_MABX_B.Switch1_k4 == L4_MABX_ConstB.Width_iw);

  }



  /* End of Outputs for SubSystem: '<S1>/BUS_OFF_RECOVERY_3' */



  /* S-Function (rti_commonblock): '<S19>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* dSPACE RTICAN Status block */

  /* ... read status variables of the CAN microcontroller */

  {

    UInt32 loop_counter, memory, j;

    for (j=0;j<=9;j++) {

      rtican_type1_tq_error[1][6] = can_tp1_service_read

        (can_type1_service_M2_C2[j]);

      loop_counter = 0;

      while ((rtican_type1_tq_error[1][6] = can_tp1_service_request

              (can_type1_service_M2_C2[j]))== DSMCOM_BUFFER_OVERFLOW) {

        loop_counter++;

        if (loop_counter > MAX_LOOP) {

          memory = rtican_type1_error_level;

          rtican_type1_error_level = 1;

          rtican_type1_tq_err_sig(1, 6);

          rtican_type1_error_level = memory;

          break;

        }

      }



      if (j==CANTP1_M2_C2_RXLost) {

        rtican_type1_tq_error[1][6] = can_tp1_service_read

          (can_type1_service_M2_C2[CANTP1_M2_C2_DataLost]);

        loop_counter = 0;

        while ((rtican_type1_tq_error[1][6] = can_tp1_service_request

                (can_type1_service_M2_C2[CANTP1_M2_C2_DataLost]))==

               DSMCOM_BUFFER_OVERFLOW) {

          loop_counter++;

          if (loop_counter > MAX_LOOP) {

            memory = rtican_type1_error_level;

            rtican_type1_error_level = 1;

            rtican_type1_tq_err_sig(1, 6);

            rtican_type1_error_level = memory;

            break;

          }

        }

      }

    }



    L4_MABX_B.SFunction1_o1_ma = (UInt32)

      can_type1_service_M2_C2[CANTP1_M2_C2_Status]->data0;

    DIAG_CAN4_Count_Stuff_Errors = (UInt32)

      can_type1_service_M2_C2[CANTP1_M2_C2_StuffErrors]->data0;

    DIAG_CAN4_Count_Format_Errors = (UInt32)

      can_type1_service_M2_C2[CANTP1_M2_C2_FormatErrors]->data0;

    DIAG_CAN4_Count_Ack_Errors = (UInt32)

      can_type1_service_M2_C2[CANTP1_M2_C2_AckErrors]->data0;

    DIAG_CAN4_Count_Bit0_Errors = (UInt32)

      can_type1_service_M2_C2[CANTP1_M2_C2_Bit0Errors]->data0;

    DIAG_CAN4_Count_Bit1_Errors = (UInt32)

      can_type1_service_M2_C2[CANTP1_M2_C2_Bit1Errors]->data0;

    DIAG_CAN4_Count_CRC_Errors = (UInt32)

      can_type1_service_M2_C2[CANTP1_M2_C2_CRCErrors]->data0;

    DIAG_CAN4_Count_RX_Lost = (UInt32)

      (can_type1_service_M2_C2[CANTP1_M2_C2_RXLost]->data0 +

       can_type1_service_M2_C2[CANTP1_M2_C2_DataLost]->data0);

    DIAG_CAN4_Count_RX_OK = (UInt32) can_type1_service_M2_C2[CANTP1_M2_C2_RXOK

      ]->data0;

    DIAG_CAN4_Count_TX_OK = (UInt32) can_type1_service_M2_C2[CANTP1_M2_C2_TXOK

      ]->data0;

  }



  /* DataTypeConversion: '<S1>/Data Type Conversion2' */

  DIAG_CAN4_Status = (ENUM_CAN_STATUS_DIAG_T)safe_cast_to_ENUM_CAN_STATUS_DI

    ((int32_T)L4_MABX_B.SFunction1_o1_ma);



  /* RelationalOperator: '<S25>/Operator' incorporates:

   *  Constant: '<S1>/Constant3'

   */

  L4_MABX_B.Operator_bw = (L4_MABX_P.Constant3_Value_h == DIAG_CAN4_Status);



  /* Outputs for Enabled SubSystem: '<S1>/BUS_OFF_RECOVERY_4' incorporates:

   *  EnablePort: '<S14>/Enable'

   */

  if (L4_MABX_B.Operator_bw) {

    /* Reshape: '<S48>/Reshape' incorporates:

     *  Constant: '<S48>/Constant'

     */

    L4_MABX_B.Reshape_n[0] = L4_MABX_P.Repeating_Sequence_Stair_OutV_n[0];

    L4_MABX_B.Reshape_n[1] = L4_MABX_P.Repeating_Sequence_Stair_OutV_n[1];



    /* UnitDelay: '<S48>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_fl = L4_MABX_DW.Unit_Delay_DSTATE_mq;



    /* UnitDelay: '<S49>/Unit Delay' */

    L4_MABX_B.UnitDelay_l = L4_MABX_DW.UnitDelay_DSTATE_h;



    /* Switch: '<S52>/Switch1' incorporates:

     *  Constant: '<S49>/E'

     *  Constant: '<S49>/IV'

     *  Switch: '<S51>/Switch1'

     */

    if (L4_MABX_B.Unit_Delay_fl) {

      L4_MABX_B.Switch1_ex = L4_MABX_P.IV_Value_k;

    } else {

      if (L4_MABX_P.E_Value_m) {

        /* Sum: '<S49>/Subtract' incorporates:

         *  Constant: '<S49>/Constant'

         *  Switch: '<S51>/Switch1'

         */

        q0 = L4_MABX_P.Constant_Value_o0;

        qY = q0 + L4_MABX_B.UnitDelay_l;

        if (qY < q0) {

          qY = MAX_uint32_T;

        }



        L4_MABX_B.Subtract_f1 = qY;



        /* End of Sum: '<S49>/Subtract' */



        /* Switch: '<S51>/Switch1' */

        L4_MABX_B.Switch1_c = L4_MABX_B.Subtract_f1;

      } else {

        /* Switch: '<S51>/Switch1' */

        L4_MABX_B.Switch1_c = L4_MABX_B.UnitDelay_l;

      }



      L4_MABX_B.Switch1_ex = L4_MABX_B.Switch1_c;

    }



    /* End of Switch: '<S52>/Switch1' */



    /* Selector: '<S48>/Selector' */

    L4_MABX_B.Selector_i = L4_MABX_B.Reshape_n[(int32_T)L4_MABX_B.Switch1_ex - 1];



    /* Outputs for Triggered SubSystem: '<S14>/CAN_TYPE1_BOR_M2_C2' incorporates:

     *  TriggerPort: '<S47>/Trigger'

     */

    zcEvent = (((L4_MABX_PrevZCX.CAN_TYPE1_BOR_M2_C2_Trig_ZCE == POS_ZCSIG) !=

                (int32_T)L4_MABX_B.Selector_i) &&

               (L4_MABX_PrevZCX.CAN_TYPE1_BOR_M2_C2_Trig_ZCE !=

                UNINITIALIZED_ZCSIG));

    if (zcEvent) {

      /* S-Function (rti_commonblock): '<S47>/S-Function1' */

      /* This comment workarounds a code generation problem */



      /* dSPACE RTICAN Bus Off Recovery block */

      /* ... Perform software-reset of the CAN microcontroller */

      {

        UInt32 loop_counter, memory;

        loop_counter = 0;

        while ((rtican_type1_tq_error[1][0] = can_tp1_channel_BOff_return

                (can_type1_channel_M2_C2)) == DSMCOM_BUFFER_OVERFLOW) {

          loop_counter++;

          if (loop_counter > MAX_LOOP) {

            memory = rtican_type1_error_level;

            rtican_type1_error_level = 1;

            rtican_type1_tq_err_sig(1, 0);

            rtican_type1_error_level = memory;

            break;

          }

        }



        while ((rtican_type1_tq_error[1][0] = can_tp1_channel_all_wakeup

                (can_type1_channel_M2_C2)) == DSMCOM_BUFFER_OVERFLOW) {

          loop_counter++;

          if (loop_counter > MAX_LOOP) {

            memory = rtican_type1_error_level;

            rtican_type1_error_level = 1;

            rtican_type1_tq_err_sig(1, 0);

            rtican_type1_error_level = memory;

            break;

          }

        }

      }

    }



    L4_MABX_PrevZCX.CAN_TYPE1_BOR_M2_C2_Trig_ZCE = L4_MABX_B.Selector_i;



    /* End of Outputs for SubSystem: '<S14>/CAN_TYPE1_BOR_M2_C2' */



    /* RelationalOperator: '<S50>/Operator' */

    L4_MABX_B.Operator_ou = (L4_MABX_B.Switch1_ex == L4_MABX_ConstB.Width_i);

  }



  /* End of Outputs for SubSystem: '<S1>/BUS_OFF_RECOVERY_4' */



  /* S-Function (rti_commonblock): '<S17>/S-Function1' */

  /* This comment workarounds a code generation problem */



  /* dSPACE RTICAN Status block */

  /* ... read status variables of the CAN microcontroller */

  {

    UInt32 loop_counter, memory, j;

    for (j=0;j<=9;j++) {

      rtican_type1_tq_error[0][6] = can_tp1_service_read

        (can_type1_service_M1_C2[j]);

      loop_counter = 0;

      while ((rtican_type1_tq_error[0][6] = can_tp1_service_request

              (can_type1_service_M1_C2[j]))== DSMCOM_BUFFER_OVERFLOW) {

        loop_counter++;

        if (loop_counter > MAX_LOOP) {

          memory = rtican_type1_error_level;

          rtican_type1_error_level = 1;

          rtican_type1_tq_err_sig(0, 6);

          rtican_type1_error_level = memory;

          break;

        }

      }



      if (j==CANTP1_M1_C2_RXLost) {

        rtican_type1_tq_error[0][6] = can_tp1_service_read

          (can_type1_service_M1_C2[CANTP1_M1_C2_DataLost]);

        loop_counter = 0;

        while ((rtican_type1_tq_error[0][6] = can_tp1_service_request

                (can_type1_service_M1_C2[CANTP1_M1_C2_DataLost]))==

               DSMCOM_BUFFER_OVERFLOW) {

          loop_counter++;

          if (loop_counter > MAX_LOOP) {

            memory = rtican_type1_error_level;

            rtican_type1_error_level = 1;

            rtican_type1_tq_err_sig(0, 6);

            rtican_type1_error_level = memory;

            break;

          }

        }

      }

    }



    L4_MABX_B.SFunction1_o1_og = (UInt32)

      can_type1_service_M1_C2[CANTP1_M1_C2_Status]->data0;

    DIAG_CAN2_Count_Stuff_Errors = (UInt32)

      can_type1_service_M1_C2[CANTP1_M1_C2_StuffErrors]->data0;

    DIAG_CAN2_Count_Format_Errors = (UInt32)

      can_type1_service_M1_C2[CANTP1_M1_C2_FormatErrors]->data0;

    DIAG_CAN2_Count_Ack_Errors = (UInt32)

      can_type1_service_M1_C2[CANTP1_M1_C2_AckErrors]->data0;

    DIAG_CAN2_Count_Bit0_Errors = (UInt32)

      can_type1_service_M1_C2[CANTP1_M1_C2_Bit0Errors]->data0;

    DIAG_CAN2_Count_Bit1_Errors = (UInt32)

      can_type1_service_M1_C2[CANTP1_M1_C2_Bit1Errors]->data0;

    DIAG_CAN2_Count_CRC_Errors = (UInt32)

      can_type1_service_M1_C2[CANTP1_M1_C2_CRCErrors]->data0;

    DIAG_CAN2_Count_RX_Lost = (UInt32)

      (can_type1_service_M1_C2[CANTP1_M1_C2_RXLost]->data0 +

       can_type1_service_M1_C2[CANTP1_M1_C2_DataLost]->data0);

    DIAG_CAN2_Count_RX_OK = (UInt32) can_type1_service_M1_C2[CANTP1_M1_C2_RXOK

      ]->data0;

    DIAG_CAN2_Count_TX_OK = (UInt32) can_type1_service_M1_C2[CANTP1_M1_C2_TXOK

      ]->data0;

  }



  /* DataTypeConversion: '<S1>/Data Type Conversion1' */

  DIAG_CAN2_Status = (ENUM_CAN_STATUS_DIAG_T)safe_cast_to_ENUM_CAN_STATUS_DI

    ((int32_T)L4_MABX_B.SFunction1_o1_og);



  /* RelationalOperator: '<S23>/Operator' incorporates:

   *  Constant: '<S1>/Constant2'

   */

  L4_MABX_B.Operator_eb = (L4_MABX_P.Constant2_Value_j2 == DIAG_CAN2_Status);



  /* Outputs for Enabled SubSystem: '<S1>/BUS_OFF_RECOVERY_2' incorporates:

   *  EnablePort: '<S12>/Enable'

   */

  if (L4_MABX_B.Operator_eb) {

    /* Reshape: '<S36>/Reshape' incorporates:

     *  Constant: '<S36>/Constant'

     */

    L4_MABX_B.Reshape_a5[0] = L4_MABX_P.Repeating_Sequence_Stair_OutV_d[0];

    L4_MABX_B.Reshape_a5[1] = L4_MABX_P.Repeating_Sequence_Stair_OutV_d[1];



    /* UnitDelay: '<S36>/Unit_Delay' */

    L4_MABX_B.Unit_Delay_g1 = L4_MABX_DW.Unit_Delay_DSTATE_je;



    /* UnitDelay: '<S37>/Unit Delay' */

    L4_MABX_B.UnitDelay_b = L4_MABX_DW.UnitDelay_DSTATE_b;



    /* Switch: '<S40>/Switch1' incorporates:

     *  Constant: '<S37>/E'

     *  Constant: '<S37>/IV'

     *  Switch: '<S39>/Switch1'

     */

    if (L4_MABX_B.Unit_Delay_g1) {

      L4_MABX_B.Switch1_i = L4_MABX_P.IV_Value_e;

    } else {

      if (L4_MABX_P.E_Value_l) {

        /* Sum: '<S37>/Subtract' incorporates:

         *  Constant: '<S37>/Constant'

         *  Switch: '<S39>/Switch1'

         */

        q0 = L4_MABX_P.Constant_Value_ae;

        qY = q0 + L4_MABX_B.UnitDelay_b;

        if (qY < q0) {

          qY = MAX_uint32_T;

        }



        L4_MABX_B.Subtract_nc = qY;



        /* End of Sum: '<S37>/Subtract' */



        /* Switch: '<S39>/Switch1' */

        L4_MABX_B.Switch1_hm = L4_MABX_B.Subtract_nc;

      } else {

        /* Switch: '<S39>/Switch1' */

        L4_MABX_B.Switch1_hm = L4_MABX_B.UnitDelay_b;

      }



      L4_MABX_B.Switch1_i = L4_MABX_B.Switch1_hm;

    }



    /* End of Switch: '<S40>/Switch1' */



    /* Selector: '<S36>/Selector' */

    L4_MABX_B.Selector_b = L4_MABX_B.Reshape_a5[(int32_T)L4_MABX_B.Switch1_i - 1];



    /* Outputs for Triggered SubSystem: '<S12>/CAN_TYPE1_BOR_M1_C2' incorporates:

     *  TriggerPort: '<S35>/Trigger'

     */

    zcEvent = (((L4_MABX_PrevZCX.CAN_TYPE1_BOR_M1_C2_Trig_ZCE == POS_ZCSIG) !=

                (int32_T)L4_MABX_B.Selector_b) &&

               (L4_MABX_PrevZCX.CAN_TYPE1_BOR_M1_C2_Trig_ZCE !=

                UNINITIALIZED_ZCSIG));

    if (zcEvent) {

      /* S-Function (rti_commonblock): '<S35>/S-Function1' */

      /* This comment workarounds a code generation problem */



      /* dSPACE RTICAN Bus Off Recovery block */

      /* ... Perform software-reset of the CAN microcontroller */

      {

        UInt32 loop_counter, memory;

        loop_counter = 0;

        while ((rtican_type1_tq_error[0][0] = can_tp1_channel_BOff_return

                (can_type1_channel_M1_C2)) == DSMCOM_BUFFER_OVERFLOW) {

          loop_counter++;

          if (loop_counter > MAX_LOOP) {

            memory = rtican_type1_error_level;

            rtican_type1_error_level = 1;

            rtican_type1_tq_err_sig(0, 0);

            rtican_type1_error_level = memory;

            break;

          }

        }



        while ((rtican_type1_tq_error[0][0] = can_tp1_channel_all_wakeup

                (can_type1_channel_M1_C2)) == DSMCOM_BUFFER_OVERFLOW) {

          loop_counter++;

          if (loop_counter > MAX_LOOP) {

            memory = rtican_type1_error_level;

            rtican_type1_error_level = 1;

            rtican_type1_tq_err_sig(0, 0);

            rtican_type1_error_level = memory;

            break;

          }

        }

      }

    }



    L4_MABX_PrevZCX.CAN_TYPE1_BOR_M1_C2_Trig_ZCE = L4_MABX_B.Selector_b;



    /* End of Outputs for SubSystem: '<S12>/CAN_TYPE1_BOR_M1_C2' */



    /* RelationalOperator: '<S38>/Operator' */

    L4_MABX_B.Operator_bsv = (L4_MABX_B.Switch1_i == L4_MABX_ConstB.Width_g);

  }



  /* End of Outputs for SubSystem: '<S1>/BUS_OFF_RECOVERY_2' */

  /* user code (Output function Trailer for TID5) */



  /* XCP Data Capture block: <Root>/RTIEthXCP Data Capture */

  /* EventChannel: 0 */

  if (tid == 0) {

    DSXCP_service(0);

  }



  /* If subsystem generates rate grouping Output functions,

   * when tid is used in Output function for one rate,

   * all Output functions include tid as a local variable.

   * As result, some Output functions may have unused tid.

   */

  UNUSED_PARAMETER(tid);

}



/* Model update function for TID5 */

void L4_MABX_update5(void)             /* Sample time: [0.5s, 0.0s] */

{

  /* Update for Enabled SubSystem: '<S1>/BUS_OFF_RECOVERY_1' incorporates:

   *  EnablePort: '<S11>/Enable'

   */

  if (L4_MABX_B.Operator_euc) {

    /* Update for UnitDelay: '<S30>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_f1 = L4_MABX_B.Operator_f5;



    /* Update for UnitDelay: '<S31>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_j1 = L4_MABX_B.Switch1_o;

  }



  /* End of Update for SubSystem: '<S1>/BUS_OFF_RECOVERY_1' */



  /* Update for Enabled SubSystem: '<S1>/BUS_OFF_RECOVERY_5' incorporates:

   *  EnablePort: '<S15>/Enable'

   */

  if (L4_MABX_B.Operator_msz) {

    /* Update for UnitDelay: '<S54>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_i5 = L4_MABX_B.Operator_ho;



    /* Update for UnitDelay: '<S55>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_p = L4_MABX_B.Switch1_k;

  }



  /* End of Update for SubSystem: '<S1>/BUS_OFF_RECOVERY_5' */



  /* Update for Enabled SubSystem: '<S1>/BUS_OFF_RECOVERY_6' incorporates:

   *  EnablePort: '<S16>/Enable'

   */

  if (L4_MABX_B.Operator_fv) {

    /* Update for UnitDelay: '<S60>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_l5 = L4_MABX_B.Operator_bg;



    /* Update for UnitDelay: '<S61>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_dr = L4_MABX_B.Switch1_h;

  }



  /* End of Update for SubSystem: '<S1>/BUS_OFF_RECOVERY_6' */



  /* Update for Enabled SubSystem: '<S1>/BUS_OFF_RECOVERY_3' incorporates:

   *  EnablePort: '<S13>/Enable'

   */

  if (L4_MABX_B.Operator_bsh) {

    /* Update for UnitDelay: '<S42>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_h41 = L4_MABX_B.Operator_dh;



    /* Update for UnitDelay: '<S43>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_dr4 = L4_MABX_B.Switch1_k4;

  }



  /* End of Update for SubSystem: '<S1>/BUS_OFF_RECOVERY_3' */



  /* Update for Enabled SubSystem: '<S1>/BUS_OFF_RECOVERY_4' incorporates:

   *  EnablePort: '<S14>/Enable'

   */

  if (L4_MABX_B.Operator_bw) {

    /* Update for UnitDelay: '<S48>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_mq = L4_MABX_B.Operator_ou;



    /* Update for UnitDelay: '<S49>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_h = L4_MABX_B.Switch1_ex;

  }



  /* End of Update for SubSystem: '<S1>/BUS_OFF_RECOVERY_4' */



  /* Update for Enabled SubSystem: '<S1>/BUS_OFF_RECOVERY_2' incorporates:

   *  EnablePort: '<S12>/Enable'

   */

  if (L4_MABX_B.Operator_eb) {

    /* Update for UnitDelay: '<S36>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_je = L4_MABX_B.Operator_bsv;



    /* Update for UnitDelay: '<S37>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_b = L4_MABX_B.Switch1_i;

  }



  /* End of Update for SubSystem: '<S1>/BUS_OFF_RECOVERY_2' */

}



/* Model output function for TID6 */

void L4_MABX_output6(void)             /* Sample time: [1.0s, 0.0s] */

{

  int_T tid = 6;



  /* Outputs for Atomic SubSystem: '<S855>/CAN_TX_1000ms' */



  /* DataTypeConversion: '<S867>/Data Type Conversion' incorporates:

   *  Constant: '<S858>/Constant2'

   */

  L4_MABX_B.DataTypeConversion_kz = (uint8_T)L4_MABX_P.Constant2_Value_k;



  /* S-Function (sfix_bitop): '<S872>/Operator' */

  L4_MABX_B.Operator_jo = (uint8_T)(L4_MABX_B.DataTypeConversion_kz &

    L4_MABX_P.Operator_BitMask);



  /* DataTypeConversion: '<S872>/DataType' */

  L4_MABX_B.DataType_o5 = L4_MABX_B.Operator_jo;



  /* ArithShift: '<S867>/Shift_Arithmetic 2' */

  L4_MABX_B.Shift_Arithmetic2_a = ldexp(L4_MABX_B.DataType_o5, (-3));



  /* DataTypeConversion: '<S867>/Data Type Conversion5' */

  L4_MABX_B.DataTypeConversion5_op = (L4_MABX_B.Shift_Arithmetic2_a != 0.0);



  /* Outputs for Enabled SubSystem: '<S875>/AIR1' incorporates:

   *  EnablePort: '<S876>/Enable'

   */

  if (L4_MABX_B.DataTypeConversion5_op) {

    /* S-Function (rti_commonblock): '<S876>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "AIR1" Id:419343921 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEAE31]);



      /* Convert timestamp */

      if (can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEAE31]->processed) {

        can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEAE31]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEAE31]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEAE31]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_bs = (real_T)

          can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEAE31]->processed;

        L4_MABX_B.SFunction1_o2_ad = (real_T)

          can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEAE31]->timestamp;

        L4_MABX_B.SFunction1_o3_dz = (real_T)

          can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEAE31]->deltatime;

        L4_MABX_B.SFunction1_o4_hw = (real_T)

          can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEAE31]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "PneumaticSupplyPress" (0|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.PneumaticSupplyPress - ( 0 )

          ) / 8 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "ParkingAnd_orTrailerAirPress" (8|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ParkingAnd_orTrailerAirPress

          - ( 0 ) ) / 8 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "ServiceBrakeCircuit1AirPress" (16|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ServiceBrakeCircuit1AirPress

          - ( 0 ) ) / 8 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "ServiceBrakeCircuit2AirPress" (24|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.ServiceBrakeCircuit2AirPress

          - ( 0 ) ) / 8 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "AuxEquipmentSupplyPress" (32|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.AuxEquipmentSupplyPress -

          ( 0 ) ) / 8 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "AirSuspensionSupplyPress" (40|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.AirSuspensionSupplyPress - (

          0 ) ) / 8 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "AirCompressorStatus" (48|2, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.AirCompressorStatus ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x00000003;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "PowertrainCircuitAirSupplyPress" (56|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32)

          (( L4_MABX_B.PowertrainCircuitAirSupplyPress - ( 0 ) ) / 8 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte0;

      }



      /* mask unused bits with '1' */

      CAN_Msg[6] |= 0xFC;



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEAE31], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  /* End of Outputs for SubSystem: '<S875>/AIR1' */



  /* S-Function (sfix_bitop): '<S869>/Operator' */

  L4_MABX_B.Operator_ed = (uint8_T)(L4_MABX_B.DataTypeConversion_kz &

    L4_MABX_P.Operator_BitMask_d);



  /* DataTypeConversion: '<S869>/DataType' */

  L4_MABX_B.DataType_kt = L4_MABX_B.Operator_ed;



  /* S-Function (sfix_bitop): '<S870>/Operator' */

  L4_MABX_B.Operator_g1 = (uint8_T)(L4_MABX_B.DataTypeConversion_kz &

    L4_MABX_P.Operator_BitMask_o);



  /* DataTypeConversion: '<S870>/DataType' */

  L4_MABX_B.DataType_eg = L4_MABX_B.Operator_g1;



  /* S-Function (sfix_bitop): '<S871>/Operator' */

  L4_MABX_B.Operator_ka = (uint8_T)(L4_MABX_B.DataTypeConversion_kz &

    L4_MABX_P.Operator_BitMask_c);



  /* DataTypeConversion: '<S871>/DataType' */

  L4_MABX_B.DataType_d5 = L4_MABX_B.Operator_ka;



  /* S-Function (sfix_bitop): '<S873>/Operator' */

  L4_MABX_B.Operator_hp = (uint8_T)(L4_MABX_B.DataTypeConversion_kz &

    L4_MABX_P.Operator_BitMask_dc);



  /* DataTypeConversion: '<S873>/DataType' */

  L4_MABX_B.DataType_mb = L4_MABX_B.Operator_hp;



  /* S-Function (sfix_bitop): '<S874>/Operator' */

  L4_MABX_B.Operator_oo = (uint8_T)(L4_MABX_B.DataTypeConversion_kz &

    L4_MABX_P.Operator_BitMask_b);



  /* DataTypeConversion: '<S874>/DataType' */

  L4_MABX_B.DataType_iw = L4_MABX_B.Operator_oo;



  /* DataTypeConversion: '<S867>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_gf = (L4_MABX_B.DataType_kt != 0);



  /* ArithShift: '<S867>/Shift_Arithmetic ' */

  L4_MABX_B.Shift_Arithmetic_l = ldexp(L4_MABX_B.DataType_eg, (-1));



  /* DataTypeConversion: '<S867>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_do = (L4_MABX_B.Shift_Arithmetic_l != 0.0);



  /* ArithShift: '<S867>/Shift_Arithmetic 1' */

  L4_MABX_B.Shift_Arithmetic1_d = ldexp(L4_MABX_B.DataType_d5, (-2));



  /* DataTypeConversion: '<S867>/Data Type Conversion4' */

  L4_MABX_B.DataTypeConversion4_ma = (L4_MABX_B.Shift_Arithmetic1_d != 0.0);



  /* ArithShift: '<S867>/Shift_Arithmetic 3' */

  L4_MABX_B.Shift_Arithmetic3_b = ldexp(L4_MABX_B.DataType_mb, (-4));



  /* DataTypeConversion: '<S867>/Data Type Conversion6' */

  L4_MABX_B.DataTypeConversion6_gt = (L4_MABX_B.Shift_Arithmetic3_b != 0.0);



  /* ArithShift: '<S867>/Shift_Arithmetic 4' */

  L4_MABX_B.Shift_Arithmetic4_m = ldexp(L4_MABX_B.DataType_iw, (-5));



  /* DataTypeConversion: '<S867>/Data Type Conversion7' */

  L4_MABX_B.DataTypeConversion7_p2 = (L4_MABX_B.Shift_Arithmetic4_m != 0.0);



  /* DataTypeConversion: '<S868>/Data Type Conversion' incorporates:

   *  Constant: '<S858>/Constant1'

   */

  L4_MABX_B.DataTypeConversion_bk = (uint8_T)L4_MABX_P.Constant1_Value_og;



  /* S-Function (sfix_bitop): '<S880>/Operator' */

  L4_MABX_B.Operator_pz = (uint8_T)(L4_MABX_B.DataTypeConversion_bk &

    L4_MABX_P.Operator_BitMask_ou);



  /* DataTypeConversion: '<S880>/DataType' */

  L4_MABX_B.DataType_ba = L4_MABX_B.Operator_pz;



  /* ArithShift: '<S868>/Shift_Arithmetic 2' */

  L4_MABX_B.Shift_Arithmetic2_j = ldexp(L4_MABX_B.DataType_ba, (-3));



  /* DataTypeConversion: '<S868>/Data Type Conversion5' */

  L4_MABX_B.DataTypeConversion5_pl = (L4_MABX_B.Shift_Arithmetic2_j != 0.0);



  /* Outputs for Enabled SubSystem: '<S883>/AMB' incorporates:

   *  EnablePort: '<S884>/Enable'

   */

  if (L4_MABX_B.DataTypeConversion5_pl) {

    /* S-Function (rti_commonblock): '<S884>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "AMB" Id:419362048 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEF500]);



      /* Convert timestamp */

      if (can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEF500]->processed) {

        can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEF500]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEF500]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEF500]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_lt = (real_T)

          can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEF500]->processed;

        L4_MABX_B.SFunction1_o2_n = (real_T)

          can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEF500]->timestamp;

        L4_MABX_B.SFunction1_o3_ea = (real_T)

          can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEF500]->deltatime;

        L4_MABX_B.SFunction1_o4_d0 = (real_T)

          can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEF500]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "BarometricPress" (0|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.BarometricPress_p - ( 0 ) ) /

          0.5 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "CabInteriorTemp" (8|16, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.CabInteriorTemp - ( -273 ) )

          / 0.03125 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte1;



        /* ...... "AmbientAirTemp" (24|16, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.AmbientAirTemp_a - ( -273 ) )

          / 0.03125 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

        CAN_Msg[3] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[4] |= CAN_Sgn.SgnBytes.Byte1;



        /* ...... "EngAirIntakeTemp" (40|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (L4_MABX_B.EngAirIntakeTemp - ( -40 ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[5] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "RoadSurfaceTemp" (48|16, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.RoadSurfaceTemp - ( -273 ) )

          / 0.03125 + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x0000FFFF;

        CAN_Msg[6] |= CAN_Sgn.SgnBytes.Byte0;

        CAN_Msg[7] |= CAN_Sgn.SgnBytes.Byte1;

      }



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEF500], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  /* End of Outputs for SubSystem: '<S883>/AMB' */



  /* S-Function (sfix_bitop): '<S877>/Operator' */

  L4_MABX_B.Operator_osm = (uint8_T)(L4_MABX_B.DataTypeConversion_bk &

    L4_MABX_P.Operator_BitMask_h);



  /* DataTypeConversion: '<S877>/DataType' */

  L4_MABX_B.DataType_lb = L4_MABX_B.Operator_osm;



  /* S-Function (sfix_bitop): '<S878>/Operator' */

  L4_MABX_B.Operator_he = (uint8_T)(L4_MABX_B.DataTypeConversion_bk &

    L4_MABX_P.Operator_BitMask_k);



  /* DataTypeConversion: '<S878>/DataType' */

  L4_MABX_B.DataType_il = L4_MABX_B.Operator_he;



  /* S-Function (sfix_bitop): '<S879>/Operator' */

  L4_MABX_B.Operator_nu = (uint8_T)(L4_MABX_B.DataTypeConversion_bk &

    L4_MABX_P.Operator_BitMask_e);



  /* DataTypeConversion: '<S879>/DataType' */

  L4_MABX_B.DataType_jc = L4_MABX_B.Operator_nu;



  /* S-Function (sfix_bitop): '<S881>/Operator' */

  L4_MABX_B.Operator_gl = (uint8_T)(L4_MABX_B.DataTypeConversion_bk &

    L4_MABX_P.Operator_BitMask_og);



  /* DataTypeConversion: '<S881>/DataType' */

  L4_MABX_B.DataType_gq = L4_MABX_B.Operator_gl;



  /* S-Function (sfix_bitop): '<S882>/Operator' */

  L4_MABX_B.Operator_kk = (uint8_T)(L4_MABX_B.DataTypeConversion_bk &

    L4_MABX_P.Operator_BitMask_g);



  /* DataTypeConversion: '<S882>/DataType' */

  L4_MABX_B.DataType_jn = L4_MABX_B.Operator_kk;



  /* DataTypeConversion: '<S868>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_pt = (L4_MABX_B.DataType_lb != 0);



  /* ArithShift: '<S868>/Shift_Arithmetic ' */

  L4_MABX_B.Shift_Arithmetic_o = ldexp(L4_MABX_B.DataType_il, (-1));



  /* DataTypeConversion: '<S868>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_np = (L4_MABX_B.Shift_Arithmetic_o != 0.0);



  /* ArithShift: '<S868>/Shift_Arithmetic 1' */

  L4_MABX_B.Shift_Arithmetic1_dz = ldexp(L4_MABX_B.DataType_jc, (-2));



  /* DataTypeConversion: '<S868>/Data Type Conversion4' */

  L4_MABX_B.DataTypeConversion4_ae = (L4_MABX_B.Shift_Arithmetic1_dz != 0.0);



  /* ArithShift: '<S868>/Shift_Arithmetic 3' */

  L4_MABX_B.Shift_Arithmetic3_an = ldexp(L4_MABX_B.DataType_gq, (-4));



  /* DataTypeConversion: '<S868>/Data Type Conversion6' */

  L4_MABX_B.DataTypeConversion6_dh = (L4_MABX_B.Shift_Arithmetic3_an != 0.0);



  /* ArithShift: '<S868>/Shift_Arithmetic 4' */

  L4_MABX_B.Shift_Arithmetic4_n = ldexp(L4_MABX_B.DataType_jn, (-5));



  /* DataTypeConversion: '<S868>/Data Type Conversion7' */

  L4_MABX_B.DataTypeConversion7_c0 = (L4_MABX_B.Shift_Arithmetic4_n != 0.0);



  /* End of Outputs for SubSystem: '<S855>/CAN_TX_1000ms' */

  /* user code (Output function Trailer for TID6) */



  /* XCP Data Capture block: <Root>/RTIEthXCP Data Capture */

  /* EventChannel: 0 */

  if (tid == 0) {

    DSXCP_service(0);

  }



  /* If subsystem generates rate grouping Output functions,

   * when tid is used in Output function for one rate,

   * all Output functions include tid as a local variable.

   * As result, some Output functions may have unused tid.

   */

  UNUSED_PARAMETER(tid);

}



/* Model update function for TID6 */

void L4_MABX_update6(void)             /* Sample time: [1.0s, 0.0s] */

{

  /* (no update code required) */

}



/* Model output function for TID7 */

void L4_MABX_output7(void)             /* Sample time: [5.0s, 0.0s] */

{

  int_T tid = 7;

  int32_T i;

  uint16_T tmp;

  uint32_T q0;

  uint32_T qY;



  /* Outputs for Atomic SubSystem: '<S855>/CAN_TX_5000ms' */



  /* DataTypeConversion: '<S1046>/Data Type Conversion6' incorporates:

   *  Constant: '<S1046>/Enable_TX_RequestDiagMsgFromREAX'

   */

  L4_MABX_B.DataTypeConversion6_k = L4_MABX_P.Enable_TX_RequestDiagMsgFromREA;



  /* Logic: '<S1050>/Operator' */

  L4_MABX_B.Operator_fc3 = (L4_MABX_B.DataTypeConversion6_k &&

    L4_MABX_B.TmpRTBAtOperatorInport2);



  /* DataTypeConversion: '<S1050>/DataType' */

  L4_MABX_B.DataType_mo = L4_MABX_B.Operator_fc3;



  /* Reshape: '<S1055>/Reshape' incorporates:

   *  Constant: '<S1055>/Constant'

   */

  for (i = 0; i < 8; i++) {

    L4_MABX_B.Reshape[i] = L4_MABX_P.Repeating_Sequence_Stair_OutVal[i];

  }



  /* End of Reshape: '<S1055>/Reshape' */



  /* UnitDelay: '<S1055>/Unit_Delay' */

  L4_MABX_B.Unit_Delay_bi = L4_MABX_DW.Unit_Delay_DSTATE_a;



  /* UnitDelay: '<S1056>/Unit Delay' */

  L4_MABX_B.UnitDelay_i = L4_MABX_DW.UnitDelay_DSTATE_a;



  /* Switch: '<S1059>/Switch1' incorporates:

   *  Constant: '<S1056>/E'

   *  Constant: '<S1056>/IV'

   *  Switch: '<S1058>/Switch1'

   */

  if (L4_MABX_B.Unit_Delay_bi) {

    L4_MABX_B.Switch1_p2 = L4_MABX_P.IV_Value_i;

  } else {

    if (L4_MABX_P.E_Value_g) {

      /* Sum: '<S1056>/Subtract' incorporates:

       *  Constant: '<S1056>/Constant'

       *  Switch: '<S1058>/Switch1'

       */

      q0 = L4_MABX_P.Constant_Value_h4;

      qY = q0 + L4_MABX_B.UnitDelay_i;

      if (qY < q0) {

        qY = MAX_uint32_T;

      }



      L4_MABX_B.Subtract_en = qY;



      /* End of Sum: '<S1056>/Subtract' */



      /* Switch: '<S1058>/Switch1' */

      L4_MABX_B.Switch1_md = L4_MABX_B.Subtract_en;

    } else {

      /* Switch: '<S1058>/Switch1' */

      L4_MABX_B.Switch1_md = L4_MABX_B.UnitDelay_i;

    }



    L4_MABX_B.Switch1_p2 = L4_MABX_B.Switch1_md;

  }



  /* End of Switch: '<S1059>/Switch1' */



  /* Selector: '<S1055>/Selector' */

  L4_MABX_B.Selector = L4_MABX_B.Reshape[(int32_T)L4_MABX_B.Switch1_p2 - 1];



  /* DataTypeConversion: '<S1047>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_gb = L4_MABX_B.Selector;



  /* S-Function (sfix_bitop): '<S1052>/Operator' */

  L4_MABX_B.Operator = L4_MABX_B.DataTypeConversion_gb &

    L4_MABX_P.Operator_BitMask_ge;



  /* DataTypeConversion: '<S1052>/DataType' */

  q0 = L4_MABX_B.Operator;

  if (q0 > 255U) {

    q0 = 255U;

  }



  L4_MABX_B.DataType_hg = (uint8_T)q0;



  /* End of DataTypeConversion: '<S1052>/DataType' */



  /* DataTypeConversion: '<S1047>/Data Type Conversion3' */

  L4_MABX_B.DataTypeConversion3_ga = L4_MABX_B.DataType_hg;



  /* DataTypeConversion: '<S1049>/Data Type Conversion' */

  L4_MABX_B.DataTypeConversion_l = L4_MABX_B.DataTypeConversion3_ga;



  /* S-Function (sfix_bitop): '<S1053>/Operator' */

  L4_MABX_B.Operator_b = L4_MABX_B.DataTypeConversion_gb &

    L4_MABX_P.Operator_BitMask_eq;



  /* DataTypeConversion: '<S1053>/DataType' */

  q0 = L4_MABX_B.Operator_b;

  if (q0 > 65535U) {

    q0 = 65535U;

  }



  L4_MABX_B.DataType_hj = (uint16_T)q0;



  /* End of DataTypeConversion: '<S1053>/DataType' */



  /* ArithShift: '<S1047>/Shift_Arithmetic ' */

  L4_MABX_B.Shift_Arithmetic_b = (uint16_T)((uint32_T)L4_MABX_B.DataType_hj >> 8);



  /* DataTypeConversion: '<S1047>/Data Type Conversion1' */

  tmp = L4_MABX_B.Shift_Arithmetic_b;

  if (tmp > 255) {

    tmp = 255U;

  }



  L4_MABX_B.DataTypeConversion1_eu = (uint8_T)tmp;



  /* End of DataTypeConversion: '<S1047>/Data Type Conversion1' */



  /* DataTypeConversion: '<S1049>/Data Type Conversion1' */

  L4_MABX_B.DataTypeConversion1_h = L4_MABX_B.DataTypeConversion1_eu;



  /* S-Function (sfix_bitop): '<S1054>/Operator' */

  L4_MABX_B.Operator_d = L4_MABX_B.DataTypeConversion_gb &

    L4_MABX_P.Operator_BitMask_ms;



  /* DataTypeConversion: '<S1054>/DataType' */

  L4_MABX_B.DataType_mh = L4_MABX_B.Operator_d;



  /* ArithShift: '<S1047>/Shift_Arithmetic 1' */

  L4_MABX_B.Shift_Arithmetic1_j3 = L4_MABX_B.DataType_mh >> 16;



  /* DataTypeConversion: '<S1047>/Data Type Conversion2' */

  q0 = L4_MABX_B.Shift_Arithmetic1_j3;

  if (q0 > 255U) {

    q0 = 255U;

  }



  L4_MABX_B.DataTypeConversion2_g5 = (uint8_T)q0;



  /* End of DataTypeConversion: '<S1047>/Data Type Conversion2' */



  /* DataTypeConversion: '<S1049>/Data Type Conversion2' */

  L4_MABX_B.DataTypeConversion2_bv = L4_MABX_B.DataTypeConversion2_g5;



  /* Outputs for Enabled SubSystem: '<S1049>/RQST_13_E4' incorporates:

   *  EnablePort: '<S1051>/Enable'

   */

  if (L4_MABX_B.DataType_mo) {

    /* S-Function (rti_commonblock): '<S1051>/S-Function1' */

    /* This comment workarounds a code generation problem */



    /* dSPACE RTICAN TX Message Block: "RQST_13_E4" Id:417993700 */

    {

      UInt32 CAN_Msg[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };



      Float32 delayTime = 0.0;



      /* ... Read status and timestamp info (previous message) */

      can_tp1_msg_read(can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18EA13E4]);



      /* Convert timestamp */

      if (can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18EA13E4]->processed) {

        can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18EA13E4]->timestamp =

          rtk_dsts_time_to_simtime_convert

          (can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18EA13E4]->timestamp);

      }



      /* Messages with timestamp zero have been received in pause/stop state

         and must not be handled.

       */

      if (can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18EA13E4]->timestamp > 0.0) {

        L4_MABX_B.SFunction1_o1_p = (real_T)

          can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18EA13E4]->processed;

        L4_MABX_B.SFunction1_o2_k = (real_T)

          can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18EA13E4]->timestamp;

        L4_MABX_B.SFunction1_o3_i = (real_T)

          can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18EA13E4]->deltatime;

        L4_MABX_B.SFunction1_o4_e = (real_T)

          can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18EA13E4]->delaytime;

      }



      /* ... Encode Simulink signals of TX and RM blocks*/

      {

        rtican_Signal_t CAN_Sgn;



        /* ...... "byte1" (0|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion_l ) + 0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[0] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte2" (8|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion1_h ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[1] |= CAN_Sgn.SgnBytes.Byte0;



        /* ...... "byte3" (16|8, standard signal, unsigned int, little endian) */

        /* Add or substract 0.5 in order to round to nearest integer */

        CAN_Sgn.UnsignedSgn = (UInt32) (( L4_MABX_B.DataTypeConversion2_bv ) +

          0.5);

        CAN_Sgn.UnsignedSgn &= 0x000000FF;

        CAN_Msg[2] |= CAN_Sgn.SgnBytes.Byte0;

      }



      /* ... Write the data to the CAN microcontroller and trigger the sending of the message */

      can_tp1_msg_send(can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18EA13E4], 8,

                       &(CAN_Msg[0]), delayTime);

    }

  }



  /* End of Outputs for SubSystem: '<S1049>/RQST_13_E4' */



  /* RelationalOperator: '<S1057>/Operator' */

  L4_MABX_B.Operator_ee = (L4_MABX_B.Switch1_p2 == L4_MABX_B.Width);



  /* End of Outputs for SubSystem: '<S855>/CAN_TX_5000ms' */

  /* user code (Output function Trailer for TID7) */



  /* XCP Data Capture block: <Root>/RTIEthXCP Data Capture */

  /* EventChannel: 0 */

  if (tid == 0) {

    DSXCP_service(0);

  }



  /* If subsystem generates rate grouping Output functions,

   * when tid is used in Output function for one rate,

   * all Output functions include tid as a local variable.

   * As result, some Output functions may have unused tid.

   */

  UNUSED_PARAMETER(tid);

}



/* Model update function for TID7 */

void L4_MABX_update7(void)             /* Sample time: [5.0s, 0.0s] */

{

  /* Update for Atomic SubSystem: '<S855>/CAN_TX_5000ms' */



  /* Update for UnitDelay: '<S1055>/Unit_Delay' */

  L4_MABX_DW.Unit_Delay_DSTATE_a = L4_MABX_B.Operator_ee;



  /* Update for UnitDelay: '<S1056>/Unit Delay' */

  L4_MABX_DW.UnitDelay_DSTATE_a = L4_MABX_B.Switch1_p2;



  /* End of Update for SubSystem: '<S855>/CAN_TX_5000ms' */

}



/* Model output function for TID8 */

void L4_MABX_output8(void)             /* Sample time: [10.0s, 0.0s] */

{

  int_T tid = 8;



  /* user code (Output function Trailer for TID8) */



  /* XCP Data Capture block: <Root>/RTIEthXCP Data Capture */

  /* EventChannel: 0 */

  if (tid == 0) {

    DSXCP_service(0);

  }



  /* If subsystem generates rate grouping Output functions,

   * when tid is used in Output function for one rate,

   * all Output functions include tid as a local variable.

   * As result, some Output functions may have unused tid.

   */

  UNUSED_PARAMETER(tid);

}



/* Model update function for TID8 */

void L4_MABX_update8(void)             /* Sample time: [10.0s, 0.0s] */

{

  /* (no update code required) */

}



/* Model output wrapper function for compatibility with a static main program */

void L4_MABX_output(int_T tid)

{

  switch (tid) {

   case 0 :

    L4_MABX_output0();

    break;



   case 1 :

    L4_MABX_output1();

    break;



   case 2 :

    L4_MABX_output2();

    break;



   case 3 :

    L4_MABX_output3();

    break;



   case 4 :

    L4_MABX_output4();

    break;



   case 5 :

    L4_MABX_output5();

    break;



   case 6 :

    L4_MABX_output6();

    break;



   case 7 :

    L4_MABX_output7();

    break;



   case 8 :

    L4_MABX_output8();

    break;



   default :

    break;

  }

}



/* Model update wrapper function for compatibility with a static main program */

void L4_MABX_update(int_T tid)

{

  switch (tid) {

   case 0 :

    L4_MABX_update0();

    break;



   case 1 :

    L4_MABX_update1();

    break;



   case 2 :

    L4_MABX_update2();

    break;



   case 3 :

    L4_MABX_update3();

    break;



   case 4 :

    L4_MABX_update4();

    break;



   case 5 :

    L4_MABX_update5();

    break;



   case 6 :

    L4_MABX_update6();

    break;



   case 7 :

    L4_MABX_update7();

    break;



   case 8 :

    L4_MABX_update8();

    break;



   default :

    break;

  }

}



/* Model initialize function */

void L4_MABX_initialize(void)

{

  /* Registration code */



  /* initialize non-finites */

  rt_InitInfAndNaN(sizeof(real_T));



  /* non-finite (run-time) assignments */

  L4_MABX_P.Saturation_UpperSat = rtInf;

  L4_MABX_P.Saturation_UpperSat_o = rtInf;

  L4_MABX_P.Saturation_UpperSat_f = rtInf;

  L4_MABX_P.Saturation1_UpperSat_j = rtInf;

  L4_MABX_P.Saturation_UpperSat_l = rtInf;

  L4_MABX_P.Saturation_UpperSat_o1 = rtInf;

  L4_MABX_P.Saturation_UpperSat_d = rtInf;

  L4_MABX_P.Saturation_UpperSat_ok = rtInf;

  L4_MABX_P.Saturation_UpperSat_ld = rtInf;

  L4_MABX_P.Saturation_UpperSat_b = rtInf;

  L4_MABX_P.Calculate_D_term_h.Saturation_UpperSat = rtInf;

  L4_MABX_P.Calculate_D_term_p.Saturation_UpperSat = rtInf;

  L4_MABX_P.Calculate_D_term.Saturation_UpperSat = rtInf;



  /* initialize real-time model */

  (void) memset((void *)L4_MABX_M, 0,

                sizeof(RT_MODEL_L4_MABX_T));

  (L4_MABX_M)->Timing.TaskCounters.cLimit[0] = 1;

  (L4_MABX_M)->Timing.TaskCounters.cLimit[1] = 2;

  (L4_MABX_M)->Timing.TaskCounters.cLimit[2] = 5;

  (L4_MABX_M)->Timing.TaskCounters.cLimit[3] = 10;

  (L4_MABX_M)->Timing.TaskCounters.cLimit[4] = 25;

  (L4_MABX_M)->Timing.TaskCounters.cLimit[5] = 50;

  (L4_MABX_M)->Timing.TaskCounters.cLimit[6] = 100;

  (L4_MABX_M)->Timing.TaskCounters.cLimit[7] = 500;

  (L4_MABX_M)->Timing.TaskCounters.cLimit[8] = 1000;

  rtsiSetSolverName(&L4_MABX_M->solverInfo,"FixedStepDiscrete");

  L4_MABX_M->solverInfoPtr = (&L4_MABX_M->solverInfo);



  /* Initialize timing info */

  {

    int_T *mdlTsMap = L4_MABX_M->Timing.sampleTimeTaskIDArray;

    int_T i;

    for (i = 0; i < 9; i++) {

      mdlTsMap[i] = i;

    }



    L4_MABX_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);

    L4_MABX_M->Timing.sampleTimes = (&L4_MABX_M->Timing.sampleTimesArray[0]);

    L4_MABX_M->Timing.offsetTimes = (&L4_MABX_M->Timing.offsetTimesArray[0]);



    /* task periods */

    L4_MABX_M->Timing.sampleTimes[0] = (0.01);

    L4_MABX_M->Timing.sampleTimes[1] = (0.02);

    L4_MABX_M->Timing.sampleTimes[2] = (0.05);

    L4_MABX_M->Timing.sampleTimes[3] = (0.1);

    L4_MABX_M->Timing.sampleTimes[4] = (0.25);

    L4_MABX_M->Timing.sampleTimes[5] = (0.5);

    L4_MABX_M->Timing.sampleTimes[6] = (1.0);

    L4_MABX_M->Timing.sampleTimes[7] = (5.0);

    L4_MABX_M->Timing.sampleTimes[8] = (10.0);



    /* task offsets */

    L4_MABX_M->Timing.offsetTimes[0] = (0.0);

    L4_MABX_M->Timing.offsetTimes[1] = (0.0);

    L4_MABX_M->Timing.offsetTimes[2] = (0.0);

    L4_MABX_M->Timing.offsetTimes[3] = (0.0);

    L4_MABX_M->Timing.offsetTimes[4] = (0.0);

    L4_MABX_M->Timing.offsetTimes[5] = (0.0);

    L4_MABX_M->Timing.offsetTimes[6] = (0.0);

    L4_MABX_M->Timing.offsetTimes[7] = (0.0);

    L4_MABX_M->Timing.offsetTimes[8] = (0.0);

  }



  rtmSetTPtr(L4_MABX_M, &L4_MABX_M->Timing.tArray[0]);



  {

    int_T *mdlSampleHits = L4_MABX_M->Timing.sampleHitArray;

    int_T *mdlPerTaskSampleHits = L4_MABX_M->Timing.perTaskSampleHitsArray;

    L4_MABX_M->Timing.perTaskSampleHits = (&mdlPerTaskSampleHits[0]);

    mdlSampleHits[0] = 1;

    L4_MABX_M->Timing.sampleHits = (&mdlSampleHits[0]);

  }



  rtmSetTFinal(L4_MABX_M, -1);

  L4_MABX_M->Timing.stepSize0 = 0.01;

  L4_MABX_M->Timing.stepSize9 = 2.3283064365386963E-10;

  L4_MABX_M->Timing.stepSize10 = 2.3283064365386963E-10;

  L4_MABX_M->Timing.stepSize11 = 2.3283064365386963E-10;

  L4_MABX_M->solverInfoPtr = (&L4_MABX_M->solverInfo);

  L4_MABX_M->Timing.stepSize = (0.01);

  rtsiSetFixedStepSize(&L4_MABX_M->solverInfo, 0.01);

  rtsiSetSolverMode(&L4_MABX_M->solverInfo, SOLVER_MODE_MULTITASKING);



  /* block I/O */

  (void) memset(((void *) &L4_MABX_B), 0,

                sizeof(B_L4_MABX_T));



  {

    L4_MABX_B.EPBPCMInhibitStatusFeedback = ENUM_XPR_FEEDBACK_T_NOT_AVAILABLE;

    L4_MABX_B.EPBPCMInhibitStatusFeedback_i = ENUM_XPR_FEEDBACK_T_NOT_AVAILABLE;

    L4_MABX_B.EPBPCMManualStatusFeedback = ENUM_XPR_FEEDBACK_T_NOT_AVAILABLE;

    L4_MABX_B.EPBPCMManualStatusFeedback_j = ENUM_XPR_FEEDBACK_T_NOT_AVAILABLE;

    L4_MABX_B.EPBPCMInhibitStatusFeedback_g = ENUM_XPR_FEEDBACK_T_NOT_AVAILABLE;

    L4_MABX_B.EPBPCMInhibitStatusFeedback_k = ENUM_XPR_FEEDBACK_T_NOT_AVAILABLE;

    L4_MABX_B.EPBPCMManualStatusFeedback_g = ENUM_XPR_FEEDBACK_T_NOT_AVAILABLE;

    L4_MABX_B.EPBPCMManualStatusFeedback_h = ENUM_XPR_FEEDBACK_T_NOT_AVAILABLE;

    L4_MABX_B.XPRErrorState = ENUM_XPR_ERROR_STATE_T_XPR_OK;

    L4_MABX_B.XPRErrorState_d = ENUM_XPR_ERROR_STATE_T_XPR_OK;

    L4_MABX_B.XPRControlMode = ENUM_XPR_CONTROL_MODE_T_NO_BRAKE_DEMAND;

    L4_MABX_B.XPRControlMode_d = ENUM_XPR_CONTROL_MODE_T_NO_BRAKE_DEMAND;

    L4_MABX_B.XBRPassThroughActive = ENUM_XBR_PASS_THROUGH_ACTIVE_T_NOT_ACTIVE;

    L4_MABX_B.DataTypeConversion_lr = ENUM_SWITCH_T_OFF;

    L4_MABX_B.DataTypeConversion1_lu = ENUM_SWITCH_T_OFF;

    L4_MABX_B.Pedal_2_pwm_health_state = ENUM_SIGNAL_HEALTH_T_FAULT_INACTIVE;

    L4_MABX_B.Pedal_1_pwm_health_state = ENUM_SIGNAL_HEALTH_T_FAULT_INACTIVE;

    L4_MABX_B.BrkPedArbBrakeSwitch = ENUM_J1939_SWITCH_T_OFF;

    L4_MABX_B.BrkPedArbBrakeSwitch_c = ENUM_J1939_SWITCH_T_OFF;

    L4_MABX_B.DataTypeConversion1_cy = ENUM_J1939_SWITCH_T_OFF;

    L4_MABX_B.DataTypeConversion3_l = ENUM_J1939_SWITCH_T_OFF;

    L4_MABX_B.VehCtrlState = ENUM_AUTO_CTRL_VEHICLE_STATE_T_NOT_AVAILABLE;

    L4_MABX_B.CtrlState = ENUM_AUTO_CTRL_STATE_T_NOT_AVAILABLE;

    L4_MABX_B.If_Then_Else_b2.XBRPriority = ENUM_XBR_PRIORITY_T_HIGHEST_PRIORITY;

    L4_MABX_B.If_Then_Else_b2.XBRPassThroughActive =

      ENUM_XBR_PASS_THROUGH_ACTIVE_T_NOT_ACTIVE;

    L4_MABX_B.If_Then_Else_b2.XBREnduranceBrakeIntegrationMod =

      ENUM_XBR_EBI_MODE_T_NO_EBI_ALLOWED;

    L4_MABX_B.If_Then_Else_b2.XBRControlMode =

      ENUM_XBR_CONTROL_MODE_T_OVERRIDE_DISABLED;

  }



  /* exported global signals */

  GLB_Absolute_Timestamp = 0.0;

  ReAX_ActualHandwheelPos = 0.0;

  EthernetLinkStatus = 0.0;

  CurrentAzimuth_rad = 0.0;

  TargetAzimuth_rad = 0.0;

  TargetVelocity_kph = 0.0;

  Curvature = 0.0;

  CrosstrackError = 0.0;

  CurrentVelocity_kph = 0.0;

  GPS_X = 0.0;

  GPS_Y = 0.0;

  GPS_Time = 0.0;

  ReAX_EchoedSteerWheelPos = 0.0;

  SteerWheelAngle = 0.0;

  YawRate = 0.0;

  SPN1810_LongitudinalAcceleration = 0.0;

  WheelBasedVehicleSpeed = 0.0;

  BrakeSwitch = 0.0;

  Lateral_Control_Rate_Limit = 0.0;

  Lateral_Control_Output = 0.0;

  Lateral_Control_Rate_Limiter_Output = 0.0;

  Stanley_Rate_Limit = 0.0;

  Stanley_Set_Gain = 0.0;

  Understeer_Correction_Output = 0.0;

  Stanley_Output = 0.0;

  Stanley_Rate_Limiter_Output = 0.0;

  SteerCommandDeg = 0.0;

  DesiredSteeringAngle = 0.0;

  Lateral_Control_Heading_Error = 0.0;

  DIAG_CAN1_Count_Stuff_Errors = 0U;

  DIAG_CAN1_Count_Format_Errors = 0U;

  DIAG_CAN1_Count_Ack_Errors = 0U;

  DIAG_CAN1_Count_Bit0_Errors = 0U;

  DIAG_CAN1_Count_Bit1_Errors = 0U;

  DIAG_CAN1_Count_CRC_Errors = 0U;

  DIAG_CAN1_Count_RX_Lost = 0U;

  DIAG_CAN1_Count_RX_OK = 0U;

  DIAG_CAN1_Count_TX_OK = 0U;

  DIAG_CAN5_Count_Stuff_Errors = 0U;

  DIAG_CAN5_Count_Format_Errors = 0U;

  DIAG_CAN5_Count_Ack_Errors = 0U;

  DIAG_CAN5_Count_Bit0_Errors = 0U;

  DIAG_CAN5_Count_Bit1_Errors = 0U;

  DIAG_CAN5_Count_CRC_Errors = 0U;

  DIAG_CAN5_Count_RX_Lost = 0U;

  DIAG_CAN5_Count_RX_OK = 0U;

  DIAG_CAN5_Count_TX_OK = 0U;

  DIAG_CAN6_Count_Stuff_Errors = 0U;

  DIAG_CAN6_Count_Format_Errors = 0U;

  DIAG_CAN6_Count_Ack_Errors = 0U;

  DIAG_CAN6_Count_Bit0_Errors = 0U;

  DIAG_CAN6_Count_Bit1_Errors = 0U;

  DIAG_CAN6_Count_CRC_Errors = 0U;

  DIAG_CAN6_Count_RX_Lost = 0U;

  DIAG_CAN6_Count_RX_OK = 0U;

  DIAG_CAN6_Count_TX_OK = 0U;

  DIAG_CAN3_Count_Stuff_Errors = 0U;

  DIAG_CAN3_Count_Format_Errors = 0U;

  DIAG_CAN3_Count_Ack_Errors = 0U;

  DIAG_CAN3_Count_Bit0_Errors = 0U;

  DIAG_CAN3_Count_Bit1_Errors = 0U;

  DIAG_CAN3_Count_CRC_Errors = 0U;

  DIAG_CAN3_Count_RX_Lost = 0U;

  DIAG_CAN3_Count_RX_OK = 0U;

  DIAG_CAN3_Count_TX_OK = 0U;

  DIAG_CAN4_Count_Stuff_Errors = 0U;

  DIAG_CAN4_Count_Format_Errors = 0U;

  DIAG_CAN4_Count_Ack_Errors = 0U;

  DIAG_CAN4_Count_Bit0_Errors = 0U;

  DIAG_CAN4_Count_Bit1_Errors = 0U;

  DIAG_CAN4_Count_CRC_Errors = 0U;

  DIAG_CAN4_Count_RX_Lost = 0U;

  DIAG_CAN4_Count_RX_OK = 0U;

  DIAG_CAN4_Count_TX_OK = 0U;

  DIAG_CAN2_Count_Stuff_Errors = 0U;

  DIAG_CAN2_Count_Format_Errors = 0U;

  DIAG_CAN2_Count_Ack_Errors = 0U;

  DIAG_CAN2_Count_Bit0_Errors = 0U;

  DIAG_CAN2_Count_Bit1_Errors = 0U;

  DIAG_CAN2_Count_CRC_Errors = 0U;

  DIAG_CAN2_Count_RX_Lost = 0U;

  DIAG_CAN2_Count_RX_OK = 0U;

  DIAG_CAN2_Count_TX_OK = 0U;

  REAX_Handwheel_Torque = 0.0F;

  REAX_Handwheel_Velocity = 0.0F;

  REAX_Pull_Compensation = 0.0F;

  DIAG_CAN1_Status = ENUM_CAN_STATUS_DIAG_T_ACTIVE;

  DIAG_CAN5_Status = ENUM_CAN_STATUS_DIAG_T_ACTIVE;

  DIAG_CAN6_Status = ENUM_CAN_STATUS_DIAG_T_ACTIVE;

  DIAG_CAN3_Status = ENUM_CAN_STATUS_DIAG_T_ACTIVE;

  DIAG_CAN4_Status = ENUM_CAN_STATUS_DIAG_T_ACTIVE;

  DIAG_CAN2_Status = ENUM_CAN_STATUS_DIAG_T_ACTIVE;

  SupervisorMode = 0U;

  REAX_Current_Mode = 0U;

  REAX_Req_Mode = 0U;

  REAX_Status = 0U;



  {

    int32_T i;

    for (i = 0; i < 100; i++) {

      GLB_SWVERSION_CPV_[i] = ((uint8_T)0U);

    }

  }



  MABX_Mode = 0U;

  EStop = false;

  EnableSw = false;

  EngagePB = false;

  BrakeSW = false;

  MABX_Heartbeat = false;

  Heartbeat_Ok = false;

  RTMapsOk = false;

  LogEventPB = false;

  AutonomousOutputEnabled = false;

  Stanley_Limiter_Active = false;

  RateLimiterActive = false;

  Pedal_pwm_position = 0.0;



  /* states (dwork) */

  (void) memset((void *)&L4_MABX_DW, 0,

                sizeof(DW_L4_MABX_T));



  /* child S-Function registration */

  {

    RTWSfcnInfo *sfcnInfo = &L4_MABX_M->NonInlinedSFcns.sfcnInfo;

    L4_MABX_M->sfcnInfo = (sfcnInfo);

    rtssSetErrorStatusPtr(sfcnInfo, (&rtmGetErrorStatus(L4_MABX_M)));

    rtssSetNumRootSampTimesPtr(sfcnInfo, &L4_MABX_M->Sizes.numSampTimes);

    L4_MABX_M->NonInlinedSFcns.taskTimePtrs[0] = &(rtmGetTPtr(L4_MABX_M)[0]);

    L4_MABX_M->NonInlinedSFcns.taskTimePtrs[1] = &(rtmGetTPtr(L4_MABX_M)[1]);

    L4_MABX_M->NonInlinedSFcns.taskTimePtrs[2] = &(rtmGetTPtr(L4_MABX_M)[2]);

    L4_MABX_M->NonInlinedSFcns.taskTimePtrs[3] = &(rtmGetTPtr(L4_MABX_M)[3]);

    L4_MABX_M->NonInlinedSFcns.taskTimePtrs[4] = &(rtmGetTPtr(L4_MABX_M)[4]);

    L4_MABX_M->NonInlinedSFcns.taskTimePtrs[5] = &(rtmGetTPtr(L4_MABX_M)[5]);

    L4_MABX_M->NonInlinedSFcns.taskTimePtrs[6] = &(rtmGetTPtr(L4_MABX_M)[6]);

    L4_MABX_M->NonInlinedSFcns.taskTimePtrs[7] = &(rtmGetTPtr(L4_MABX_M)[7]);

    L4_MABX_M->NonInlinedSFcns.taskTimePtrs[8] = &(rtmGetTPtr(L4_MABX_M)[8]);

    L4_MABX_M->NonInlinedSFcns.taskTimePtrs[9] = &(rtmGetTPtr(L4_MABX_M)[9]);

    L4_MABX_M->NonInlinedSFcns.taskTimePtrs[10] = &(rtmGetTPtr(L4_MABX_M)[10]);

    L4_MABX_M->NonInlinedSFcns.taskTimePtrs[11] = &(rtmGetTPtr(L4_MABX_M)[11]);

    L4_MABX_M->NonInlinedSFcns.taskTimePtrs[12] = &(rtmGetTPtr(L4_MABX_M)[12]);

    rtssSetTPtrPtr(sfcnInfo,L4_MABX_M->NonInlinedSFcns.taskTimePtrs);

    rtssSetTStartPtr(sfcnInfo, &rtmGetTStart(L4_MABX_M));

    rtssSetTFinalPtr(sfcnInfo, &rtmGetTFinal(L4_MABX_M));

    rtssSetTimeOfLastOutputPtr(sfcnInfo, &rtmGetTimeOfLastOutput(L4_MABX_M));

    rtssSetStepSizePtr(sfcnInfo, &L4_MABX_M->Timing.stepSize);

    rtssSetStopRequestedPtr(sfcnInfo, &rtmGetStopRequested(L4_MABX_M));

    rtssSetDerivCacheNeedsResetPtr(sfcnInfo, &L4_MABX_M->derivCacheNeedsReset);

    rtssSetZCCacheNeedsResetPtr(sfcnInfo, &L4_MABX_M->zCCacheNeedsReset);

    rtssSetContTimeOutputInconsistentWithStateAtMajorStepPtr(sfcnInfo,

      &L4_MABX_M->CTOutputIncnstWithState);

    rtssSetSampleHitsPtr(sfcnInfo, &L4_MABX_M->Timing.sampleHits);

    rtssSetPerTaskSampleHitsPtr(sfcnInfo, &L4_MABX_M->Timing.perTaskSampleHits);

    rtssSetSimModePtr(sfcnInfo, &L4_MABX_M->simMode);

    rtssSetSolverInfoPtr(sfcnInfo, &L4_MABX_M->solverInfoPtr);

  }



  L4_MABX_M->Sizes.numSFcns = (5);



  /* register each child */

  {

    (void) memset((void *)&L4_MABX_M->NonInlinedSFcns.childSFunctions[0], 0,

                  5*sizeof(SimStruct));

    L4_MABX_M->childSfunctions = (&L4_MABX_M->

      NonInlinedSFcns.childSFunctionPtrs[0]);



    {

      int_T i;

      for (i = 0; i < 5; i++) {

        L4_MABX_M->childSfunctions[i] =

          (&L4_MABX_M->NonInlinedSFcns.childSFunctions[i]);

      }

    }



    /* Level2 S-Function Block: L4_MABX/<S415>/dsa_tcpip_bkg_sfcn (dsa_tcpip_bkg_sfcn) */

    {

      SimStruct *rts = L4_MABX_M->childSfunctions[0];



      /* timing info */

      time_T *sfcnPeriod = L4_MABX_M->NonInlinedSFcns.Sfcn0.sfcnPeriod;

      time_T *sfcnOffset = L4_MABX_M->NonInlinedSFcns.Sfcn0.sfcnOffset;

      int_T *sfcnTsMap = L4_MABX_M->NonInlinedSFcns.Sfcn0.sfcnTsMap;

      (void) memset((void*)sfcnPeriod, 0,

                    sizeof(time_T)*1);

      (void) memset((void*)sfcnOffset, 0,

                    sizeof(time_T)*1);

      ssSetSampleTimePtr(rts, &sfcnPeriod[0]);

      ssSetOffsetTimePtr(rts, &sfcnOffset[0]);

      ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);



      {

        ssSetBlkInfo2Ptr(rts, &L4_MABX_M->NonInlinedSFcns.blkInfo2[0]);

      }



      _ssSetBlkInfo2PortInfo2Ptr(rts,

        &L4_MABX_M->NonInlinedSFcns.inputOutputPortInfo2[0]);



      /* Set up the mdlInfo pointer */

      ssSetRTWSfcnInfo(rts, L4_MABX_M->sfcnInfo);



      /* Allocate memory of model methods 2 */

      {

        ssSetModelMethods2(rts, &L4_MABX_M->NonInlinedSFcns.methods2[0]);

      }



      /* Allocate memory of model methods 3 */

      {

        ssSetModelMethods3(rts, &L4_MABX_M->NonInlinedSFcns.methods3[0]);

      }



      /* Allocate memory of model methods 4 */

      {

        ssSetModelMethods4(rts, &L4_MABX_M->NonInlinedSFcns.methods4[0]);

      }



      /* Allocate memory for states auxilliary information */

      {

        ssSetStatesInfo2(rts, &L4_MABX_M->NonInlinedSFcns.statesInfo2[0]);

        ssSetPeriodicStatesInfo(rts,

          &L4_MABX_M->NonInlinedSFcns.periodicStatesInfo[0]);

      }



      /* path info */

      ssSetModelName(rts, "dsa_tcpip_bkg_sfcn");

      ssSetPath(rts,

                "L4_MABX/ETHERNET/TCPIP_Setup/Background_Task/dsa_tcpip_bkg_sfcn");

      ssSetRTModel(rts,L4_MABX_M);

      ssSetParentSS(rts, (NULL));

      ssSetRootSS(rts, rts);

      ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);



      /* work vectors */

      ssSetIWork(rts, (int_T *) &L4_MABX_DW.dsa_tcpip_bkg_sfcn_IWORK);



      {

        struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *)

          &L4_MABX_M->NonInlinedSFcns.Sfcn0.dWork;

        struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

          &L4_MABX_M->NonInlinedSFcns.Sfcn0.dWorkAux;

        ssSetSFcnDWork(rts, dWorkRecord);

        ssSetSFcnDWorkAux(rts, dWorkAuxRecord);

        _ssSetNumDWork(rts, 1);



        /* IWORK */

        ssSetDWorkWidth(rts, 0, 1);

        ssSetDWorkDataType(rts, 0,SS_INTEGER);

        ssSetDWorkComplexSignal(rts, 0, 0);

        ssSetDWork(rts, 0, &L4_MABX_DW.dsa_tcpip_bkg_sfcn_IWORK);

      }



      /* registration */

      dsa_tcpip_bkg_sfcn(rts);

      sfcnInitializeSizes(rts);

      sfcnInitializeSampleTimes(rts);



      /* adjust sample time */

      ssSetSampleTime(rts, 0, -1.0);

      ssSetOffsetTime(rts, 0, -2.0);

      sfcnTsMap[0] = 9;



      /* set compiled values of dynamic vector attributes */

      ssSetNumNonsampledZCs(rts, 0);



      /* Update connectivity flags for each port */

      /* Update the BufferDstPort flags for each input port */

    }



    /* Level2 S-Function Block: L4_MABX/<S416>/dsa_tcpip_irq_l2_sfcn (dsa_tcpip_irq_l2_sfcn) */

    {

      SimStruct *rts = L4_MABX_M->childSfunctions[1];



      /* timing info */

      time_T *sfcnPeriod = L4_MABX_M->NonInlinedSFcns.Sfcn1.sfcnPeriod;

      time_T *sfcnOffset = L4_MABX_M->NonInlinedSFcns.Sfcn1.sfcnOffset;

      int_T *sfcnTsMap = L4_MABX_M->NonInlinedSFcns.Sfcn1.sfcnTsMap;

      (void) memset((void*)sfcnPeriod, 0,

                    sizeof(time_T)*1);

      (void) memset((void*)sfcnOffset, 0,

                    sizeof(time_T)*1);

      ssSetSampleTimePtr(rts, &sfcnPeriod[0]);

      ssSetOffsetTimePtr(rts, &sfcnOffset[0]);

      ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);



      {

        ssSetBlkInfo2Ptr(rts, &L4_MABX_M->NonInlinedSFcns.blkInfo2[1]);

      }



      _ssSetBlkInfo2PortInfo2Ptr(rts,

        &L4_MABX_M->NonInlinedSFcns.inputOutputPortInfo2[1]);



      /* Set up the mdlInfo pointer */

      ssSetRTWSfcnInfo(rts, L4_MABX_M->sfcnInfo);



      /* Allocate memory of model methods 2 */

      {

        ssSetModelMethods2(rts, &L4_MABX_M->NonInlinedSFcns.methods2[1]);

      }



      /* Allocate memory of model methods 3 */

      {

        ssSetModelMethods3(rts, &L4_MABX_M->NonInlinedSFcns.methods3[1]);

      }



      /* Allocate memory of model methods 4 */

      {

        ssSetModelMethods4(rts, &L4_MABX_M->NonInlinedSFcns.methods4[1]);

      }



      /* Allocate memory for states auxilliary information */

      {

        ssSetStatesInfo2(rts, &L4_MABX_M->NonInlinedSFcns.statesInfo2[1]);

        ssSetPeriodicStatesInfo(rts,

          &L4_MABX_M->NonInlinedSFcns.periodicStatesInfo[1]);

      }



      /* path info */

      ssSetModelName(rts, "dsa_tcpip_irq_l2_sfcn");

      ssSetPath(rts,

                "L4_MABX/ETHERNET/TCPIP_Setup/IRQ_Level_2_SW_INT/dsa_tcpip_irq_l2_sfcn");

      ssSetRTModel(rts,L4_MABX_M);

      ssSetParentSS(rts, (NULL));

      ssSetRootSS(rts, rts);

      ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);



      /* registration */

      dsa_tcpip_irq_l2_sfcn(rts);

      sfcnInitializeSizes(rts);

      sfcnInitializeSampleTimes(rts);



      /* adjust sample time */

      ssSetSampleTime(rts, 0, -1.0);

      ssSetOffsetTime(rts, 0, -3.0);

      sfcnTsMap[0] = 10;



      /* set compiled values of dynamic vector attributes */

      ssSetNumNonsampledZCs(rts, 0);



      /* Update connectivity flags for each port */

      /* Update the BufferDstPort flags for each input port */

    }



    /* Level2 S-Function Block: L4_MABX/<S417>/dsa_tcpip_irq_l1_sfcn (dsa_tcpip_irq_l1_sfcn) */

    {

      SimStruct *rts = L4_MABX_M->childSfunctions[2];



      /* timing info */

      time_T *sfcnPeriod = L4_MABX_M->NonInlinedSFcns.Sfcn2.sfcnPeriod;

      time_T *sfcnOffset = L4_MABX_M->NonInlinedSFcns.Sfcn2.sfcnOffset;

      int_T *sfcnTsMap = L4_MABX_M->NonInlinedSFcns.Sfcn2.sfcnTsMap;

      (void) memset((void*)sfcnPeriod, 0,

                    sizeof(time_T)*1);

      (void) memset((void*)sfcnOffset, 0,

                    sizeof(time_T)*1);

      ssSetSampleTimePtr(rts, &sfcnPeriod[0]);

      ssSetOffsetTimePtr(rts, &sfcnOffset[0]);

      ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);



      {

        ssSetBlkInfo2Ptr(rts, &L4_MABX_M->NonInlinedSFcns.blkInfo2[2]);

      }



      _ssSetBlkInfo2PortInfo2Ptr(rts,

        &L4_MABX_M->NonInlinedSFcns.inputOutputPortInfo2[2]);



      /* Set up the mdlInfo pointer */

      ssSetRTWSfcnInfo(rts, L4_MABX_M->sfcnInfo);



      /* Allocate memory of model methods 2 */

      {

        ssSetModelMethods2(rts, &L4_MABX_M->NonInlinedSFcns.methods2[2]);

      }



      /* Allocate memory of model methods 3 */

      {

        ssSetModelMethods3(rts, &L4_MABX_M->NonInlinedSFcns.methods3[2]);

      }



      /* Allocate memory of model methods 4 */

      {

        ssSetModelMethods4(rts, &L4_MABX_M->NonInlinedSFcns.methods4[2]);

      }



      /* Allocate memory for states auxilliary information */

      {

        ssSetStatesInfo2(rts, &L4_MABX_M->NonInlinedSFcns.statesInfo2[2]);

        ssSetPeriodicStatesInfo(rts,

          &L4_MABX_M->NonInlinedSFcns.periodicStatesInfo[2]);

      }



      /* outputs */

      {

        ssSetPortInfoForOutputs(rts,

          &L4_MABX_M->NonInlinedSFcns.Sfcn2.outputPortInfo[0]);

        _ssSetNumOutputPorts(rts, 1);

        _ssSetPortInfo2ForOutputUnits(rts,

          &L4_MABX_M->NonInlinedSFcns.Sfcn2.outputPortUnits[0]);

        ssSetOutputPortUnit(rts, 0, 0);

        _ssSetPortInfo2ForOutputCoSimAttribute(rts,

          &L4_MABX_M->NonInlinedSFcns.Sfcn2.outputPortCoSimAttribute[0]);

        ssSetOutputPortIsContinuousQuantity(rts, 0, 0);



        /* port 0 */

        {

          _ssSetOutputPortNumDimensions(rts, 0, 1);

          ssSetOutputPortWidth(rts, 0, 1);

          ssSetOutputPortSignal(rts, 0, (NULL));

        }

      }



      /* path info */

      ssSetModelName(rts, "dsa_tcpip_irq_l1_sfcn");

      ssSetPath(rts,

                "L4_MABX/ETHERNET/TCPIP_Setup/Interrupt_Task/dsa_tcpip_irq_l1_sfcn");

      ssSetRTModel(rts,L4_MABX_M);

      ssSetParentSS(rts, (NULL));

      ssSetRootSS(rts, rts);

      ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);



      /* register function-calls */

      {

        int_T *callSysOutputs = (int_T *)

          &L4_MABX_M->NonInlinedSFcns.Sfcn2.callSysOutputs;

        void **callSysArgs1 = (void **)

          &L4_MABX_M->NonInlinedSFcns.Sfcn2.callSysArgs1;

        int_T *callSysArgs2 = (int_T *)

          &L4_MABX_M->NonInlinedSFcns.Sfcn2.callSysArgs2;

        SysOutputFcn *callSysFcns = (SysOutputFcn *)

          &L4_MABX_M->NonInlinedSFcns.Sfcn2.callSysFcns;



        {

          int32_T i;

          for (i = 0; i < 1; i++) {

            callSysOutputs[i] = 0;

            callSysFcns[i] = (SysOutputFcn) (NULL);

            callSysFcns[1+i] = (SysOutputFcn) (NULL);

            callSysFcns[2*1+i] = (SysOutputFcn) (NULL);

            callSysFcns[3*1+i] = (SysOutputFcn) (NULL);

          }

        }



        ssSetCallSystemOutputPtr(rts, &callSysOutputs[0]);

        ssSetCallSystemOutputArg1List(rts, &callSysArgs1[0]);

        ssSetCallSystemOutputArg2List(rts, &callSysArgs2[0]);

        ssSetCallSystemOutputFcnList(rts, &callSysFcns[0]);

        callSysArgs1[0] = (void *)L4_MABX_M;

        callSysArgs2[0] = 0;

        callSysFcns[0] = (SysOutputFcn) L4_MABX_TcpInputProcessingFNI;

        callSysFcns[1+0] = (SysOutputFcn) L4_TcpInputProcessing_ResetFNI;

        callSysFcns[2+0] = (SysOutputFcn) (NULL);

        callSysFcns[3+0] = (SysOutputFcn) (NULL);

        callSysOutputs[0] = 1;

      }



      /* registration */

      dsa_tcpip_irq_l1_sfcn(rts);

      sfcnInitializeSizes(rts);

      sfcnInitializeSampleTimes(rts);



      /* adjust sample time */

      ssSetSampleTime(rts, 0, -1.0);

      ssSetOffsetTime(rts, 0, -4.0);

      sfcnTsMap[0] = 11;



      /* set compiled values of dynamic vector attributes */

      ssSetOutputPortWidth(rts, 0, 1);

      ssSetNumNonsampledZCs(rts, 0);



      /* Update connectivity flags for each port */

      _ssSetOutputPortConnected(rts, 0, 1);

      _ssSetOutputPortBeingMerged(rts, 0, 0);



      /* Update the BufferDstPort flags for each input port */

    }



    /* Level2 S-Function Block: L4_MABX/<S405>/dsa_tcpip_setup (dsa_tcpip_setup_sfcn) */

    {

      SimStruct *rts = L4_MABX_M->childSfunctions[3];



      /* timing info */

      time_T *sfcnPeriod = L4_MABX_M->NonInlinedSFcns.Sfcn3.sfcnPeriod;

      time_T *sfcnOffset = L4_MABX_M->NonInlinedSFcns.Sfcn3.sfcnOffset;

      int_T *sfcnTsMap = L4_MABX_M->NonInlinedSFcns.Sfcn3.sfcnTsMap;

      (void) memset((void*)sfcnPeriod, 0,

                    sizeof(time_T)*1);

      (void) memset((void*)sfcnOffset, 0,

                    sizeof(time_T)*1);

      ssSetSampleTimePtr(rts, &sfcnPeriod[0]);

      ssSetOffsetTimePtr(rts, &sfcnOffset[0]);

      ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);



      {

        ssSetBlkInfo2Ptr(rts, &L4_MABX_M->NonInlinedSFcns.blkInfo2[3]);

      }



      _ssSetBlkInfo2PortInfo2Ptr(rts,

        &L4_MABX_M->NonInlinedSFcns.inputOutputPortInfo2[3]);



      /* Set up the mdlInfo pointer */

      ssSetRTWSfcnInfo(rts, L4_MABX_M->sfcnInfo);



      /* Allocate memory of model methods 2 */

      {

        ssSetModelMethods2(rts, &L4_MABX_M->NonInlinedSFcns.methods2[3]);

      }



      /* Allocate memory of model methods 3 */

      {

        ssSetModelMethods3(rts, &L4_MABX_M->NonInlinedSFcns.methods3[3]);

      }



      /* Allocate memory of model methods 4 */

      {

        ssSetModelMethods4(rts, &L4_MABX_M->NonInlinedSFcns.methods4[3]);

      }



      /* Allocate memory for states auxilliary information */

      {

        ssSetStatesInfo2(rts, &L4_MABX_M->NonInlinedSFcns.statesInfo2[3]);

        ssSetPeriodicStatesInfo(rts,

          &L4_MABX_M->NonInlinedSFcns.periodicStatesInfo[3]);

      }



      /* outputs */

      {

        ssSetPortInfoForOutputs(rts,

          &L4_MABX_M->NonInlinedSFcns.Sfcn3.outputPortInfo[0]);

        _ssSetNumOutputPorts(rts, 1);

        _ssSetPortInfo2ForOutputUnits(rts,

          &L4_MABX_M->NonInlinedSFcns.Sfcn3.outputPortUnits[0]);

        ssSetOutputPortUnit(rts, 0, 0);

        _ssSetPortInfo2ForOutputCoSimAttribute(rts,

          &L4_MABX_M->NonInlinedSFcns.Sfcn3.outputPortCoSimAttribute[0]);

        ssSetOutputPortIsContinuousQuantity(rts, 0, 0);



        /* port 0 */

        {

          _ssSetOutputPortNumDimensions(rts, 0, 1);

          ssSetOutputPortWidth(rts, 0, 1);

          ssSetOutputPortSignal(rts, 0, ((real_T *) &EthernetLinkStatus));

        }

      }



      /* path info */

      ssSetModelName(rts, "dsa_tcpip_setup");

      ssSetPath(rts, "L4_MABX/ETHERNET/TCPIP_Setup/dsa_tcpip_setup");

      ssSetRTModel(rts,L4_MABX_M);

      ssSetParentSS(rts, (NULL));

      ssSetRootSS(rts, rts);

      ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);



      /* parameters */

      {

        mxArray **sfcnParams = (mxArray **)

          &L4_MABX_M->NonInlinedSFcns.Sfcn3.params;

        ssSetSFcnParamsCount(rts, 6);

        ssSetSFcnParamsPtr(rts, &sfcnParams[0]);

        ssSetSFcnParam(rts, 0, (mxArray*)L4_MABX_P.dsa_tcpip_setup_P1_Size);

        ssSetSFcnParam(rts, 1, (mxArray*)L4_MABX_P.dsa_tcpip_setup_P2_Size);

        ssSetSFcnParam(rts, 2, (mxArray*)L4_MABX_P.dsa_tcpip_setup_P3_Size);

        ssSetSFcnParam(rts, 3, (mxArray*)L4_MABX_P.dsa_tcpip_setup_P4_Size);

        ssSetSFcnParam(rts, 4, (mxArray*)L4_MABX_P.dsa_tcpip_setup_P5_Size);

        ssSetSFcnParam(rts, 5, (mxArray*)L4_MABX_P.dsa_tcpip_setup_P6_Size);

      }



      /* work vectors */

      ssSetIWork(rts, (int_T *) &L4_MABX_DW.dsa_tcpip_setup_IWORK);

      ssSetPWork(rts, (void **) &L4_MABX_DW.dsa_tcpip_setup_PWORK);



      {

        struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *)

          &L4_MABX_M->NonInlinedSFcns.Sfcn3.dWork;

        struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

          &L4_MABX_M->NonInlinedSFcns.Sfcn3.dWorkAux;

        ssSetSFcnDWork(rts, dWorkRecord);

        ssSetSFcnDWorkAux(rts, dWorkAuxRecord);

        _ssSetNumDWork(rts, 2);



        /* IWORK */

        ssSetDWorkWidth(rts, 0, 1);

        ssSetDWorkDataType(rts, 0,SS_INTEGER);

        ssSetDWorkComplexSignal(rts, 0, 0);

        ssSetDWork(rts, 0, &L4_MABX_DW.dsa_tcpip_setup_IWORK);



        /* PWORK */

        ssSetDWorkWidth(rts, 1, 1);

        ssSetDWorkDataType(rts, 1,SS_POINTER);

        ssSetDWorkComplexSignal(rts, 1, 0);

        ssSetDWork(rts, 1, &L4_MABX_DW.dsa_tcpip_setup_PWORK);

      }



      /* registration */

      dsa_tcpip_setup_sfcn(rts);

      sfcnInitializeSizes(rts);

      sfcnInitializeSampleTimes(rts);



      /* adjust sample time */

      ssSetSampleTime(rts, 0, 0.01);

      ssSetOffsetTime(rts, 0, 0.0);

      sfcnTsMap[0] = 0;



      /* set compiled values of dynamic vector attributes */

      ssSetNumNonsampledZCs(rts, 0);



      /* Update connectivity flags for each port */

      _ssSetOutputPortConnected(rts, 0, 1);

      _ssSetOutputPortBeingMerged(rts, 0, 0);



      /* Update the BufferDstPort flags for each input port */

    }



    /* Level2 S-Function Block: L4_MABX/<S406>/TCPIP_Com (dsa_tcpip_udp_sfcn) */

    {

      SimStruct *rts = L4_MABX_M->childSfunctions[4];



      /* timing info */

      time_T *sfcnPeriod = L4_MABX_M->NonInlinedSFcns.Sfcn4.sfcnPeriod;

      time_T *sfcnOffset = L4_MABX_M->NonInlinedSFcns.Sfcn4.sfcnOffset;

      int_T *sfcnTsMap = L4_MABX_M->NonInlinedSFcns.Sfcn4.sfcnTsMap;

      (void) memset((void*)sfcnPeriod, 0,

                    sizeof(time_T)*1);

      (void) memset((void*)sfcnOffset, 0,

                    sizeof(time_T)*1);

      ssSetSampleTimePtr(rts, &sfcnPeriod[0]);

      ssSetOffsetTimePtr(rts, &sfcnOffset[0]);

      ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);



      {

        ssSetBlkInfo2Ptr(rts, &L4_MABX_M->NonInlinedSFcns.blkInfo2[4]);

      }



      _ssSetBlkInfo2PortInfo2Ptr(rts,

        &L4_MABX_M->NonInlinedSFcns.inputOutputPortInfo2[4]);



      /* Set up the mdlInfo pointer */

      ssSetRTWSfcnInfo(rts, L4_MABX_M->sfcnInfo);



      /* Allocate memory of model methods 2 */

      {

        ssSetModelMethods2(rts, &L4_MABX_M->NonInlinedSFcns.methods2[4]);

      }



      /* Allocate memory of model methods 3 */

      {

        ssSetModelMethods3(rts, &L4_MABX_M->NonInlinedSFcns.methods3[4]);

      }



      /* Allocate memory of model methods 4 */

      {

        ssSetModelMethods4(rts, &L4_MABX_M->NonInlinedSFcns.methods4[4]);

      }



      /* Allocate memory for states auxilliary information */

      {

        ssSetStatesInfo2(rts, &L4_MABX_M->NonInlinedSFcns.statesInfo2[4]);

        ssSetPeriodicStatesInfo(rts,

          &L4_MABX_M->NonInlinedSFcns.periodicStatesInfo[4]);

      }



      /* inputs */

      {

        _ssSetNumInputPorts(rts, 3);

        ssSetPortInfoForInputs(rts,

          &L4_MABX_M->NonInlinedSFcns.Sfcn4.inputPortInfo[0]);

        _ssSetPortInfo2ForInputUnits(rts,

          &L4_MABX_M->NonInlinedSFcns.Sfcn4.inputPortUnits[0]);

        ssSetInputPortUnit(rts, 0, 0);

        ssSetInputPortUnit(rts, 1, 0);

        ssSetInputPortUnit(rts, 2, 0);

        _ssSetPortInfo2ForInputCoSimAttribute(rts,

          &L4_MABX_M->NonInlinedSFcns.Sfcn4.inputPortCoSimAttribute[0]);

        ssSetInputPortIsContinuousQuantity(rts, 0, 0);

        ssSetInputPortIsContinuousQuantity(rts, 1, 0);

        ssSetInputPortIsContinuousQuantity(rts, 2, 0);



        /* port 0 */

        {

          boolean_T const **sfcnUPtrs = (boolean_T const **)

            &L4_MABX_M->NonInlinedSFcns.Sfcn4.UPtrs0;

          sfcnUPtrs[0] = &L4_MABX_B.Enable;

          ssSetInputPortSignalPtrs(rts, 0, (InputPtrsType)&sfcnUPtrs[0]);

          _ssSetInputPortNumDimensions(rts, 0, 1);

          ssSetInputPortWidth(rts, 0, 1);

        }



        /* port 1 */

        {

          uint32_T const **sfcnUPtrs = (uint32_T const **)

            &L4_MABX_M->NonInlinedSFcns.Sfcn4.UPtrs1;

          sfcnUPtrs[0] = &L4_MABX_B.Encoder_o2;

          ssSetInputPortSignalPtrs(rts, 1, (InputPtrsType)&sfcnUPtrs[0]);

          _ssSetInputPortNumDimensions(rts, 1, 1);

          ssSetInputPortWidth(rts, 1, 1);

        }



        /* port 2 */

        {

          uint8_T const **sfcnUPtrs = (uint8_T const **)

            &L4_MABX_M->NonInlinedSFcns.Sfcn4.UPtrs2;



          {

            int_T i1;

            const uint8_T *u2 = L4_MABX_B.Encoder_o1;

            for (i1=0; i1 < 24; i1++) {

              sfcnUPtrs[i1] = &u2[i1];

            }

          }



          ssSetInputPortSignalPtrs(rts, 2, (InputPtrsType)&sfcnUPtrs[0]);

          _ssSetInputPortNumDimensions(rts, 2, 1);

          ssSetInputPortWidth(rts, 2, 24);

        }

      }



      /* outputs */

      {

        ssSetPortInfoForOutputs(rts,

          &L4_MABX_M->NonInlinedSFcns.Sfcn4.outputPortInfo[0]);

        _ssSetNumOutputPorts(rts, 3);

        _ssSetPortInfo2ForOutputUnits(rts,

          &L4_MABX_M->NonInlinedSFcns.Sfcn4.outputPortUnits[0]);

        ssSetOutputPortUnit(rts, 0, 0);

        ssSetOutputPortUnit(rts, 1, 0);

        ssSetOutputPortUnit(rts, 2, 0);

        _ssSetPortInfo2ForOutputCoSimAttribute(rts,

          &L4_MABX_M->NonInlinedSFcns.Sfcn4.outputPortCoSimAttribute[0]);

        ssSetOutputPortIsContinuousQuantity(rts, 0, 0);

        ssSetOutputPortIsContinuousQuantity(rts, 1, 0);

        ssSetOutputPortIsContinuousQuantity(rts, 2, 0);



        /* port 0 */

        {

          _ssSetOutputPortNumDimensions(rts, 0, 1);

          ssSetOutputPortWidth(rts, 0, 3);

          ssSetOutputPortSignal(rts, 0, ((uint32_T *) L4_MABX_B.TCPIP_Com_o1));

        }



        /* port 1 */

        {

          _ssSetOutputPortNumDimensions(rts, 1, 1);

          ssSetOutputPortWidth(rts, 1, 1);

          ssSetOutputPortSignal(rts, 1, ((uint32_T *) &L4_MABX_B.TCPIP_Com_o2));

        }



        /* port 2 */

        {

          _ssSetOutputPortNumDimensions(rts, 2, 1);

          ssSetOutputPortWidth(rts, 2, 128);

          ssSetOutputPortSignal(rts, 2, ((uint8_T *) L4_MABX_B.TCPIP_Com_o3));

        }

      }



      /* path info */

      ssSetModelName(rts, "TCPIP_Com");

      ssSetPath(rts, "L4_MABX/ETHERNET/UDPIP_Communication/TCPIP_Com");

      ssSetRTModel(rts,L4_MABX_M);

      ssSetParentSS(rts, (NULL));

      ssSetRootSS(rts, rts);

      ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);



      /* parameters */

      {

        mxArray **sfcnParams = (mxArray **)

          &L4_MABX_M->NonInlinedSFcns.Sfcn4.params;

        ssSetSFcnParamsCount(rts, 6);

        ssSetSFcnParamsPtr(rts, &sfcnParams[0]);

        ssSetSFcnParam(rts, 0, (mxArray*)L4_MABX_P.TCPIP_Com_P1_Size);

        ssSetSFcnParam(rts, 1, (mxArray*)L4_MABX_P.TCPIP_Com_P2_Size);

        ssSetSFcnParam(rts, 2, (mxArray*)L4_MABX_P.TCPIP_Com_P3_Size);

        ssSetSFcnParam(rts, 3, (mxArray*)L4_MABX_P.TCPIP_Com_P4_Size);

        ssSetSFcnParam(rts, 4, (mxArray*)L4_MABX_P.TCPIP_Com_P5_Size);

        ssSetSFcnParam(rts, 5, (mxArray*)L4_MABX_P.TCPIP_Com_P6_Size);

      }



      /* work vectors */

      ssSetPWork(rts, (void **) &L4_MABX_DW.TCPIP_Com_PWORK);



      {

        struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *)

          &L4_MABX_M->NonInlinedSFcns.Sfcn4.dWork;

        struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)

          &L4_MABX_M->NonInlinedSFcns.Sfcn4.dWorkAux;

        ssSetSFcnDWork(rts, dWorkRecord);

        ssSetSFcnDWorkAux(rts, dWorkAuxRecord);

        _ssSetNumDWork(rts, 1);



        /* PWORK */

        ssSetDWorkWidth(rts, 0, 1);

        ssSetDWorkDataType(rts, 0,SS_POINTER);

        ssSetDWorkComplexSignal(rts, 0, 0);

        ssSetDWork(rts, 0, &L4_MABX_DW.TCPIP_Com_PWORK);

      }



      /* registration */

      dsa_tcpip_udp_sfcn(rts);

      sfcnInitializeSizes(rts);

      sfcnInitializeSampleTimes(rts);



      /* adjust sample time */

      ssSetSampleTime(rts, 0, 0.01);

      ssSetOffsetTime(rts, 0, 0.0);

      sfcnTsMap[0] = 0;



      /* set compiled values of dynamic vector attributes */

      ssSetNumNonsampledZCs(rts, 0);



      /* Update connectivity flags for each port */

      _ssSetInputPortConnected(rts, 0, 1);

      _ssSetInputPortConnected(rts, 1, 1);

      _ssSetInputPortConnected(rts, 2, 1);

      _ssSetOutputPortConnected(rts, 0, 1);

      _ssSetOutputPortConnected(rts, 1, 1);

      _ssSetOutputPortConnected(rts, 2, 1);

      _ssSetOutputPortBeingMerged(rts, 0, 0);

      _ssSetOutputPortBeingMerged(rts, 1, 0);

      _ssSetOutputPortBeingMerged(rts, 2, 0);



      /* Update the BufferDstPort flags for each input port */

      ssSetInputPortBufferDstPort(rts, 0, -1);

      ssSetInputPortBufferDstPort(rts, 1, -1);

      ssSetInputPortBufferDstPort(rts, 2, -1);

    }

  }



  {

    /* user code (registration function declaration) */

    /*Initialize global TRC pointers. */

    L4_MABX_rti_init_trc_pointers();

  }



  /* Start for Enabled SubSystem: '<S750>/Slew_at_event' */

  L4_MABX_DW.Slew_at_event_MODE = false;



  /* End of Start for SubSystem: '<S750>/Slew_at_event' */



  /* Start for S-Function (dsa_tcpip_setup_sfcn): '<S405>/dsa_tcpip_setup' */

  /* Level2 S-Function Block: '<S405>/dsa_tcpip_setup' (dsa_tcpip_setup_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[3];

    sfcnStart(rts);

    if (ssGetErrorStatus(rts) != (NULL))

      return;

  }



  /* Start for Constant: '<S3>/Enable' */

  L4_MABX_B.Enable = L4_MABX_P.Enable_Value;



  /* Start for S-Function (dsa_gen_tx_RTMapsEncode_sfun): '<S413>/Encoder' */

  Init_Tx_RTMapsEncode();



  /* Start for S-Function (dsa_tcpip_udp_sfcn): '<S406>/TCPIP_Com' */

  /* Level2 S-Function Block: '<S406>/TCPIP_Com' (dsa_tcpip_udp_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[4];

    sfcnStart(rts);

    if (ssGetErrorStatus(rts) != (NULL))

      return;

  }



  /* Start for S-Function (dsa_gen_rx_RTMapsDecode_sfun): '<S410>/Decoder' */

  Init_Rx_RTMapsDecode();



  /* Start for Atomic SubSystem: '<S65>/Task_10ms' */

  /* Start for RateTransition: '<S81>/TmpRTBAtSignal Conversion1Inport1' */

  L4_MABX_B.distanceSpdTarget_e = L4_MABX_P.TmpRTBAtSignalConversion1Inport;



  /* Start for Enabled SubSystem: '<S79>/Throttle_controller_gov' */

  L4_MABX_DW.Throttle_controller_gov_MODE = false;



  /* Start for Enabled SubSystem: '<S244>/Calculate_D_term' */

  L4_M_Calculate_D_term_Start(&L4_MABX_DW.Calculate_D_term_h);



  /* End of Start for SubSystem: '<S244>/Calculate_D_term' */



  /* Start for Enabled SubSystem: '<S244>/Calculate_I_term' */

  L4_M_Calculate_I_term_Start(&L4_MABX_DW.Calculate_I_term_n);



  /* End of Start for SubSystem: '<S244>/Calculate_I_term' */



  /* End of Start for SubSystem: '<S79>/Throttle_controller_gov' */



  /* Start for Enabled SubSystem: '<S105>/Determine_shift_interlock_brake_pressure_target' */

  L4_MABX_DW.Determine_shift_interlock_brake = false;



  /* End of Start for SubSystem: '<S105>/Determine_shift_interlock_brake_pressure_target' */



  /* Start for Enabled SubSystem: '<S105>/Determine_brake_hold_pressure_target' */

  L4_MABX_DW.Determine_brake_hold_pressure_t = false;



  /* End of Start for SubSystem: '<S105>/Determine_brake_hold_pressure_target' */



  /* Start for Enabled SubSystem: '<S77>/Bendix_2C2_brake_application_pressure_feedback_controller' */

  L4_MABX_DW.Bendix_2C2_brake_application_pr = false;



  /* Start for Enabled SubSystem: '<S112>/Calculate_D_term' */

  L4_M_Calculate_D_term_Start(&L4_MABX_DW.Calculate_D_term);



  /* End of Start for SubSystem: '<S112>/Calculate_D_term' */



  /* Start for Enabled SubSystem: '<S112>/Calculate_I_term' */

  L4_M_Calculate_I_term_Start(&L4_MABX_DW.Calculate_I_term);



  /* End of Start for SubSystem: '<S112>/Calculate_I_term' */



  /* End of Start for SubSystem: '<S77>/Bendix_2C2_brake_application_pressure_feedback_controller' */



  /* Start for RateTransition: '<S81>/TmpRTBAtSignal Conversion3Inport1' */

  L4_MABX_B.pathSpdLimit_a = L4_MABX_P.TmpRTBAtSignalConversion3Inport;



  /* Start for RateTransition: '<S81>/TmpRTBAtSignal Conversion2Inport1' */

  L4_MABX_B.distance_o = L4_MABX_P.TmpRTBAtSignalConversion2Inport;



  /* Start for Enabled SubSystem: '<S77>/Bendix_2C2_vehicle_speed_feedback_pressure_controller' */

  L4_MABX_DW.Bendix_2C2_vehicle_speed_feedba = false;



  /* Start for Enabled SubSystem: '<S150>/Calculate_D_term' */

  L4_M_Calculate_D_term_Start(&L4_MABX_DW.Calculate_D_term_p);



  /* End of Start for SubSystem: '<S150>/Calculate_D_term' */



  /* Start for Enabled SubSystem: '<S150>/Calculate_I_term' */

  L4_M_Calculate_I_term_Start(&L4_MABX_DW.Calculate_I_term_e);



  /* End of Start for SubSystem: '<S150>/Calculate_I_term' */



  /* End of Start for SubSystem: '<S77>/Bendix_2C2_vehicle_speed_feedback_pressure_controller' */



  /* Start for Enabled SubSystem: '<S79>/Engine_speed_target' */

  L4_MABX_DW.Engine_speed_target_MODE = false;



  /* End of Start for SubSystem: '<S79>/Engine_speed_target' */



  /* Start for Enabled SubSystem: '<S283>/Slew_at_event' */

  L4_MABX_DW.Slew_at_event_MODE_d = false;



  /* End of Start for SubSystem: '<S283>/Slew_at_event' */



  /* Start for RateTransition: '<S80>/TmpRTBAtrad2deg1Inport1' */

  L4_MABX_B.previewSteeringAngle_b = L4_MABX_P.TmpRTBAtrad2deg1Inport1_Initial;



  /* Start for RateTransition: '<S80>/TmpRTBAtsignCurveOffsetInport1' */

  L4_MABX_B.TmpRTBAtsignCurveOffsetInport1 =

    L4_MABX_P.TmpRTBAtsignCurveOffsetInport1_;



  /* Start for RateTransition: '<S284>/TmpRTBAtAdd2Inport2' */

  L4_MABX_B.TmpRTBAtAdd2Inport2 = L4_MABX_P.TmpRTBAtAdd2Inport2_InitialCond;



  /* End of Start for SubSystem: '<S65>/Task_10ms' */



  /* Start for Atomic SubSystem: '<S855>/CAN_TX_10ms' */



  /* Start for Width: '<S1012>/Width' */

  L4_MABX_B.Width_j = 16U;



  /* End of Start for SubSystem: '<S855>/CAN_TX_10ms' */



  /* Start for Atomic SubSystem: '<S855>/CAN_TX_20ms' */



  /* Start for Width: '<S1040>/Width' */

  L4_MABX_B.Width_h = 16U;



  /* End of Start for SubSystem: '<S855>/CAN_TX_20ms' */



  /* Start for Atomic SubSystem: '<S855>/CAN_TX_5000ms' */



  /* Start for Width: '<S1055>/Width' */

  L4_MABX_B.Width = 8U;



  /* End of Start for SubSystem: '<S855>/CAN_TX_5000ms' */



  /* Start for RateTransition: '<S1083>/TmpRTBAtFlashOutport1' */

  L4_MABX_B.TmpRTBAtFlashOutport1 = L4_MABX_P.TmpRTBAtFlashOutport1_InitialCo;



  /* Start for Atomic SubSystem: '<S65>/Task_20ms' */

  /* Start for Constant: '<S402>/InitialHeading' */

  L4_MABX_B.InitialHeading = L4_MABX_P.InitialHeading_Value;



  /* Start for Constant: '<S402>/InitialPosition' */

  L4_MABX_B.InitialPosition = L4_MABX_P.InitialPosition_Value;



  /* Start for Constant: '<S402>/InitialXPosition' */

  L4_MABX_B.InitialXPosition = L4_MABX_P.InitialXPosition_Value;



  /* Start for Constant: '<S402>/InitialYPosition' */

  L4_MABX_B.InitialYPosition = L4_MABX_P.InitialYPosition_Value;



  /* End of Start for SubSystem: '<S65>/Task_20ms' */



  /* Start for S-Function (rti_commonblock): '<S414>/S-Function1' incorporates:

   *  SubSystem: '<S405>/Background_Task'

   */

  L4_MA_Background_Task_Start();



  /* End of Start for S-Function (rti_commonblock): '<S414>/S-Function1' */



  /* Start for S-Function (rti_commonblock): '<S420>/S-Function1' incorporates:

   *  SubSystem: '<S405>/Interrupt_Task'

   */

  L4_MAB_Interrupt_Task_Start();



  /* End of Start for S-Function (rti_commonblock): '<S420>/S-Function1' */

  L4_MABX_PrevZCX.CAN_TYPE1_BOR_M1_C1_Trig_ZCE = UNINITIALIZED_ZCSIG;

  L4_MABX_PrevZCX.CAN_TYPE1_BOR_M1_C2_Trig_ZCE = UNINITIALIZED_ZCSIG;

  L4_MABX_PrevZCX.CAN_TYPE1_BOR_M2_C1_Trig_ZCE = UNINITIALIZED_ZCSIG;

  L4_MABX_PrevZCX.CAN_TYPE1_BOR_M2_C2_Trig_ZCE = UNINITIALIZED_ZCSIG;

  L4_MABX_PrevZCX.CAN_TYPE1_BOR_M3_C1_Trig_ZCE = UNINITIALIZED_ZCSIG;

  L4_MABX_PrevZCX.CAN_TYPE1_BOR_M3_C2_Trig_ZCE = UNINITIALIZED_ZCSIG;

  L4_MABX_PrevZCX.CAN_TYPE1_TX_M1_C1_Trig_ZCE_n = POS_ZCSIG;

  L4_MABX_PrevZCX.CAN_TYPE1_TX_M1_C1_Trig_ZCE = POS_ZCSIG;



  {

    int32_T i;



    /* InitializeConditions for UnitDelay: '<S763>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE = L4_MABX_P.UnitDelay_InitialCondition_e;



    /* InitializeConditions for UnitDelay: '<S761>/Delay Input1' */

    L4_MABX_DW.DelayInput1_DSTATE_i = L4_MABX_P.DetectRisePositive_vinit;



    /* InitializeConditions for UnitDelay: '<S762>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_i = L4_MABX_P.UnitDelay_InitialCondition_eu;



    /* InitializeConditions for UnitDelay: '<S749>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_ix = L4_MABX_P.UnitDelay_InitialCondition_bf;



    /* InitializeConditions for UnitDelay: '<S760>/Delay Input1' */

    L4_MABX_DW.DelayInput1_DSTATE_i5 = L4_MABX_P.DetectFallNonpositive_vinit_m;



    /* InitializeConditions for UnitDelay: '<S762>/Unit Delay1' */

    L4_MABX_DW.UnitDelay1_DSTATE_p = L4_MABX_P.UnitDelay1_InitialCondition_pw;



    /* InitializeConditions for UnitDelay: '<S763>/Unit Delay1' */

    L4_MABX_DW.UnitDelay1_DSTATE_h = L4_MABX_P.UnitDelay1_InitialCondition_g;



    /* InitializeConditions for UnitDelay: '<S802>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE =

      L4_MABX_P.FixPtUnitDelay2_InitialCondit_o;



    /* InitializeConditions for UnitDelay: '<S802>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE =

      L4_MABX_P.FixPtUnitDelay1_InitialCondit_e;



    /* InitializeConditions for UnitDelay: '<S794>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_d =

      L4_MABX_P.FixPtUnitDelay2_InitialCondi_i5;



    /* InitializeConditions for UnitDelay: '<S794>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_d =

      L4_MABX_P.FixPtUnitDelay1_InitialCondi_dv;



    /* InitializeConditions for UnitDelay: '<S818>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_a =

      L4_MABX_P.FixPtUnitDelay2_InitialCondit_l;



    /* InitializeConditions for UnitDelay: '<S818>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_g =

      L4_MABX_P.FixPtUnitDelay1_InitialCondi_im;



    /* InitializeConditions for UnitDelay: '<S810>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_i =

      L4_MABX_P.FixPtUnitDelay2_InitialCondit_k;



    /* InitializeConditions for UnitDelay: '<S810>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_e =

      L4_MABX_P.FixPtUnitDelay1_InitialCondi_h5;



    /* InitializeConditions for UnitDelay: '<S772>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_pw = L4_MABX_P.Unit_Delay_InitialCondition_ax;



    /* InitializeConditions for UnitDelay: '<S839>/Unit_Delay1' */

    L4_MABX_DW.Unit_Delay1_DSTATE = L4_MABX_P.Unit_Delay1_InitialCondition_i;



    /* InitializeConditions for UnitDelay: '<S839>/Unit_Delay2' */

    L4_MABX_DW.Unit_Delay2_DSTATE = L4_MABX_P.Unit_Delay2_InitialCondition_d;



    /* InitializeConditions for UnitDelay: '<S772>/Unit_Delay1' */

    L4_MABX_DW.Unit_Delay1_DSTATE_m = L4_MABX_P.Unit_Delay1_InitialCondition_k;



    /* InitializeConditions for UnitDelay: '<S840>/Unit_Delay1' */

    L4_MABX_DW.Unit_Delay1_DSTATE_p = L4_MABX_P.Unit_Delay1_InitialCondition_n;



    /* InitializeConditions for UnitDelay: '<S840>/Unit_Delay2' */

    L4_MABX_DW.Unit_Delay2_DSTATE_g = L4_MABX_P.Unit_Delay2_InitialCondition_i;



    /* InitializeConditions for UnitDelay: '<S838>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_d1 =

      L4_MABX_P.FixPtUnitDelay2_InitialCondit_n;



    /* InitializeConditions for UnitDelay: '<S838>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_n =

      L4_MABX_P.FixPtUnitDelay1_InitialCondit_c;



    /* InitializeConditions for UnitDelay: '<S837>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_g =

      L4_MABX_P.FixPtUnitDelay2_InitialCondi_pj;



    /* InitializeConditions for UnitDelay: '<S837>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_j =

      L4_MABX_P.FixPtUnitDelay1_InitialCondi_fz;



    /* InitializeConditions for UnitDelay: '<S826>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_k =

      L4_MABX_P.FixPtUnitDelay2_InitialCondit_b;



    /* InitializeConditions for UnitDelay: '<S826>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_e5 =

      L4_MABX_P.FixPtUnitDelay1_InitialCondit_a;



    /* InitializeConditions for RateTransition: '<S423>/Rate Transition' */

    L4_MABX_DW.RateTransition_Buffer0 =

      L4_MABX_P.RateTransition_InitialCondition;

    L4_MABX_DW.RateTransition_write_buf = -1;

    L4_MABX_DW.RateTransition_read_buf = -1;



    /* InitializeConditions for UnitDelay: '<S655>/Unit_Delay3' */

    L4_MABX_DW.Unit_Delay3_DSTATE = L4_MABX_P.Unit_Delay3_InitialCondition;



    /* InitializeConditions for UnitDelay: '<S655>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_h1 = L4_MABX_P.Unit_Delay_InitialCondition_ic;



    /* InitializeConditions for UnitDelay: '<S661>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_fr = L4_MABX_P.Unit_Delay_InitialCondition_oh;



    /* InitializeConditions for S-Function (dsa_tcpip_setup_sfcn): '<S405>/dsa_tcpip_setup' */

    /* Level2 S-Function Block: '<S405>/dsa_tcpip_setup' (dsa_tcpip_setup_sfcn) */

    {

      SimStruct *rts = L4_MABX_M->childSfunctions[3];

      sfcnInitializeConditions(rts);

      if (ssGetErrorStatus(rts) != (NULL))

        return;

    }



    /* InitializeConditions for DiscretePulseGenerator: '<S404>/Heartbeat' */

    L4_MABX_DW.clockTickCounter = 0;



    /* InitializeConditions for UnitDelay: '<S3>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_80_DSTATE = L4_MABX_P.Unit_Delay_80_InitialCondition;

    L4_MABX_DW.Unit_Delay_81_DSTATE = L4_MABX_P.Unit_Delay_81_InitialCondition;

    L4_MABX_DW.Unit_Delay_48_DSTATE = L4_MABX_P.Unit_Delay_48_InitialCondition;

    L4_MABX_DW.Unit_Delay_83_DSTATE = L4_MABX_P.Unit_Delay_83_InitialCondition;

    L4_MABX_DW.Unit_Delay_45_DSTATE = L4_MABX_P.Unit_Delay_45_InitialCondition;

    L4_MABX_DW.Unit_Delay_47_DSTATE = L4_MABX_P.Unit_Delay_47_InitialCondition;

    L4_MABX_DW.Unit_Delay_84_DSTATE = L4_MABX_P.Unit_Delay_84_InitialCondition;



    /* InitializeConditions for S-Function (dsa_tcpip_udp_sfcn): '<S406>/TCPIP_Com' */

    /* Level2 S-Function Block: '<S406>/TCPIP_Com' (dsa_tcpip_udp_sfcn) */

    {

      SimStruct *rts = L4_MABX_M->childSfunctions[4];

      sfcnInitializeConditions(rts);

      if (ssGetErrorStatus(rts) != (NULL))

        return;

    }



    /* InitializeConditions for UnitDelay: '<S411>/Delay Input1' */

    L4_MABX_DW.DelayInput1_DSTATE_n = L4_MABX_P.DetectRisePositive1_vinit;



    /* InitializeConditions for UnitDelay: '<S409>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_k = L4_MABX_P.UnitDelay_InitialCondition_h;



    /* InitializeConditions for UnitDelay: '<S865>/Unit Delay2' */

    L4_MABX_DW.UnitDelay2_DSTATE = L4_MABX_P.UnitDelay2_InitialCondition;



    /* InitializeConditions for UnitDelay: '<S865>/Unit Delay1' */

    L4_MABX_DW.UnitDelay1_DSTATE_mt = L4_MABX_P.UnitDelay1_InitialCondition_jy;



    /* InitializeConditions for UnitDelay: '<S865>/Unit Delay3' */

    L4_MABX_DW.UnitDelay3_DSTATE = L4_MABX_P.UnitDelay3_InitialCondition;



    /* InitializeConditions for RateTransition: '<S1083>/TmpRTBAtFlashOutport1' */

    L4_MABX_DW.TmpRTBAtFlashOutport1_Buffer0 =

      L4_MABX_P.TmpRTBAtFlashOutport1_InitialCo;



    /* InitializeConditions for DiscretePulseGenerator: '<S1083>/Flash' */

    L4_MABX_DW.clockTickCounter_k = 0;



    /* InitializeConditions for UnitDelay: '<S3>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_1_DSTATE = L4_MABX_P.Unit_Delay_1_InitialCondition_f;

    L4_MABX_DW.Unit_Delay_10_DSTATE = L4_MABX_P.Unit_Delay_10_InitialCondition;

    L4_MABX_DW.Unit_Delay_100_DSTATE = L4_MABX_P.Unit_Delay_100_InitialCondition;

    L4_MABX_DW.Unit_Delay_101_DSTATE = L4_MABX_P.Unit_Delay_101_InitialCondition;

    L4_MABX_DW.Unit_Delay_102_DSTATE = L4_MABX_P.Unit_Delay_102_InitialCondition;

    L4_MABX_DW.Unit_Delay_103_DSTATE = L4_MABX_P.Unit_Delay_103_InitialCondition;

    L4_MABX_DW.Unit_Delay_104_DSTATE = L4_MABX_P.Unit_Delay_104_InitialCondition;

    L4_MABX_DW.Unit_Delay_105_DSTATE = L4_MABX_P.Unit_Delay_105_InitialCondition;

    L4_MABX_DW.Unit_Delay_106_DSTATE = L4_MABX_P.Unit_Delay_106_InitialCondition;

    L4_MABX_DW.Unit_Delay_107_DSTATE = L4_MABX_P.Unit_Delay_107_InitialCondition;

    L4_MABX_DW.Unit_Delay_108_DSTATE = L4_MABX_P.Unit_Delay_108_InitialCondition;

    L4_MABX_DW.Unit_Delay_109_DSTATE = L4_MABX_P.Unit_Delay_109_InitialCondition;

    L4_MABX_DW.Unit_Delay_11_DSTATE = L4_MABX_P.Unit_Delay_11_InitialCondition;

    L4_MABX_DW.Unit_Delay_110_DSTATE = L4_MABX_P.Unit_Delay_110_InitialCondition;

    L4_MABX_DW.Unit_Delay_111_DSTATE = L4_MABX_P.Unit_Delay_111_InitialCondition;

    L4_MABX_DW.Unit_Delay_112_DSTATE = L4_MABX_P.Unit_Delay_112_InitialCondition;

    L4_MABX_DW.Unit_Delay_113_DSTATE = L4_MABX_P.Unit_Delay_113_InitialCondition;

    L4_MABX_DW.Unit_Delay_114_DSTATE = L4_MABX_P.Unit_Delay_114_InitialCondition;

    L4_MABX_DW.Unit_Delay_115_DSTATE = L4_MABX_P.Unit_Delay_115_InitialCondition;

    L4_MABX_DW.Unit_Delay_116_DSTATE = L4_MABX_P.Unit_Delay_116_InitialCondition;

    L4_MABX_DW.Unit_Delay_117_DSTATE = L4_MABX_P.Unit_Delay_117_InitialCondition;

    L4_MABX_DW.Unit_Delay_118_DSTATE = L4_MABX_P.Unit_Delay_118_InitialCondition;

    L4_MABX_DW.Unit_Delay_119_DSTATE = L4_MABX_P.Unit_Delay_119_InitialCondition;

    L4_MABX_DW.Unit_Delay_12_DSTATE = L4_MABX_P.Unit_Delay_12_InitialCondition;

    L4_MABX_DW.Unit_Delay_120_DSTATE = L4_MABX_P.Unit_Delay_120_InitialCondition;

    L4_MABX_DW.Unit_Delay_121_DSTATE = L4_MABX_P.Unit_Delay_121_InitialCondition;

    L4_MABX_DW.Unit_Delay_122_DSTATE = L4_MABX_P.Unit_Delay_122_InitialCondition;

    L4_MABX_DW.Unit_Delay_123_DSTATE = L4_MABX_P.Unit_Delay_123_InitialCondition;

    L4_MABX_DW.Unit_Delay_124_DSTATE = L4_MABX_P.Unit_Delay_124_InitialCondition;

    L4_MABX_DW.Unit_Delay_125_DSTATE = L4_MABX_P.Unit_Delay_125_InitialCondition;

    L4_MABX_DW.Unit_Delay_126_DSTATE = L4_MABX_P.Unit_Delay_126_InitialCondition;

    L4_MABX_DW.Unit_Delay_127_DSTATE = L4_MABX_P.Unit_Delay_127_InitialCondition;

    L4_MABX_DW.Unit_Delay_128_DSTATE = L4_MABX_P.Unit_Delay_128_InitialCondition;

    L4_MABX_DW.Unit_Delay_129_DSTATE = L4_MABX_P.Unit_Delay_129_InitialCondition;

    L4_MABX_DW.Unit_Delay_13_DSTATE = L4_MABX_P.Unit_Delay_13_InitialCondition;

    L4_MABX_DW.Unit_Delay_130_DSTATE = L4_MABX_P.Unit_Delay_130_InitialCondition;

    L4_MABX_DW.Unit_Delay_131_DSTATE = L4_MABX_P.Unit_Delay_131_InitialCondition;

    L4_MABX_DW.Unit_Delay_132_DSTATE = L4_MABX_P.Unit_Delay_132_InitialCondition;

    L4_MABX_DW.Unit_Delay_133_DSTATE = L4_MABX_P.Unit_Delay_133_InitialCondition;

    L4_MABX_DW.Unit_Delay_134_DSTATE = L4_MABX_P.Unit_Delay_134_InitialCondition;

    L4_MABX_DW.Unit_Delay_135_DSTATE = L4_MABX_P.Unit_Delay_135_InitialCondition;

    L4_MABX_DW.Unit_Delay_136_DSTATE = L4_MABX_P.Unit_Delay_136_InitialCondition;

    L4_MABX_DW.Unit_Delay_137_DSTATE = L4_MABX_P.Unit_Delay_137_InitialCondition;

    L4_MABX_DW.Unit_Delay_138_DSTATE = L4_MABX_P.Unit_Delay_138_InitialCondition;

    L4_MABX_DW.Unit_Delay_139_DSTATE = L4_MABX_P.Unit_Delay_139_InitialCondition;

    L4_MABX_DW.Unit_Delay_14_DSTATE = L4_MABX_P.Unit_Delay_14_InitialCondition;

    L4_MABX_DW.Unit_Delay_140_DSTATE = L4_MABX_P.Unit_Delay_140_InitialCondition;

    L4_MABX_DW.Unit_Delay_141_DSTATE = L4_MABX_P.Unit_Delay_141_InitialCondition;

    L4_MABX_DW.Unit_Delay_142_DSTATE = L4_MABX_P.Unit_Delay_142_InitialCondition;

    L4_MABX_DW.Unit_Delay_143_DSTATE = L4_MABX_P.Unit_Delay_143_InitialCondition;

    L4_MABX_DW.Unit_Delay_144_DSTATE = L4_MABX_P.Unit_Delay_144_InitialCondition;

    L4_MABX_DW.Unit_Delay_15_DSTATE = L4_MABX_P.Unit_Delay_15_InitialCondition;

    L4_MABX_DW.Unit_Delay_16_DSTATE = L4_MABX_P.Unit_Delay_16_InitialCondition;

    L4_MABX_DW.Unit_Delay_17_DSTATE = L4_MABX_P.Unit_Delay_17_InitialCondition;

    L4_MABX_DW.Unit_Delay_18_DSTATE = L4_MABX_P.Unit_Delay_18_InitialCondition;

    L4_MABX_DW.Unit_Delay_19_DSTATE = L4_MABX_P.Unit_Delay_19_InitialCondition;

    L4_MABX_DW.Unit_Delay_2_DSTATE = L4_MABX_P.Unit_Delay_2_InitialCondition_f;

    L4_MABX_DW.Unit_Delay_20_DSTATE = L4_MABX_P.Unit_Delay_20_InitialCondition;

    L4_MABX_DW.Unit_Delay_21_DSTATE = L4_MABX_P.Unit_Delay_21_InitialCondition;

    L4_MABX_DW.Unit_Delay_22_DSTATE = L4_MABX_P.Unit_Delay_22_InitialCondition;

    L4_MABX_DW.Unit_Delay_23_DSTATE = L4_MABX_P.Unit_Delay_23_InitialCondition;

    L4_MABX_DW.Unit_Delay_24_DSTATE = L4_MABX_P.Unit_Delay_24_InitialCondition;

    L4_MABX_DW.Unit_Delay_25_DSTATE = L4_MABX_P.Unit_Delay_25_InitialCondition;

    L4_MABX_DW.Unit_Delay_26_DSTATE = L4_MABX_P.Unit_Delay_26_InitialCondition;

    L4_MABX_DW.Unit_Delay_27_DSTATE = L4_MABX_P.Unit_Delay_27_InitialCondition;

    L4_MABX_DW.Unit_Delay_28_DSTATE = L4_MABX_P.Unit_Delay_28_InitialCondition;

    L4_MABX_DW.Unit_Delay_29_DSTATE = L4_MABX_P.Unit_Delay_29_InitialCondition;

    L4_MABX_DW.Unit_Delay_3_DSTATE = L4_MABX_P.Unit_Delay_3_InitialCondition_f;

    L4_MABX_DW.Unit_Delay_30_DSTATE = L4_MABX_P.Unit_Delay_30_InitialCondition;

    L4_MABX_DW.Unit_Delay_31_DSTATE = L4_MABX_P.Unit_Delay_31_InitialCondition;

    L4_MABX_DW.Unit_Delay_32_DSTATE = L4_MABX_P.Unit_Delay_32_InitialCondition;

    L4_MABX_DW.Unit_Delay_33_DSTATE = L4_MABX_P.Unit_Delay_33_InitialCondition;

    L4_MABX_DW.Unit_Delay_34_DSTATE = L4_MABX_P.Unit_Delay_34_InitialCondition;

    L4_MABX_DW.Unit_Delay_35_DSTATE = L4_MABX_P.Unit_Delay_35_InitialCondition;

    L4_MABX_DW.Unit_Delay_36_DSTATE = L4_MABX_P.Unit_Delay_36_InitialCondition;

    L4_MABX_DW.Unit_Delay_37_DSTATE = L4_MABX_P.Unit_Delay_37_InitialCondition;

    L4_MABX_DW.Unit_Delay_38_DSTATE = L4_MABX_P.Unit_Delay_38_InitialCondition;

    L4_MABX_DW.Unit_Delay_39_DSTATE = L4_MABX_P.Unit_Delay_39_InitialCondition;

    L4_MABX_DW.Unit_Delay_4_DSTATE = L4_MABX_P.Unit_Delay_4_InitialCondition;

    L4_MABX_DW.Unit_Delay_40_DSTATE = L4_MABX_P.Unit_Delay_40_InitialCondition;

    L4_MABX_DW.Unit_Delay_41_DSTATE = L4_MABX_P.Unit_Delay_41_InitialCondition;

    L4_MABX_DW.Unit_Delay_42_DSTATE = L4_MABX_P.Unit_Delay_42_InitialCondition;

    L4_MABX_DW.Unit_Delay_43_DSTATE = L4_MABX_P.Unit_Delay_43_InitialCondition;

    L4_MABX_DW.Unit_Delay_44_DSTATE = L4_MABX_P.Unit_Delay_44_InitialCondition;

    L4_MABX_DW.Unit_Delay_46_DSTATE = L4_MABX_P.Unit_Delay_46_InitialCondition;

    L4_MABX_DW.Unit_Delay_49_DSTATE = L4_MABX_P.Unit_Delay_49_InitialCondition;

    L4_MABX_DW.Unit_Delay_5_DSTATE = L4_MABX_P.Unit_Delay_5_InitialCondition;

    L4_MABX_DW.Unit_Delay_50_DSTATE = L4_MABX_P.Unit_Delay_50_InitialCondition;

    L4_MABX_DW.Unit_Delay_51_DSTATE = L4_MABX_P.Unit_Delay_51_InitialCondition;

    L4_MABX_DW.Unit_Delay_52_DSTATE = L4_MABX_P.Unit_Delay_52_InitialCondition;

    L4_MABX_DW.Unit_Delay_53_DSTATE = L4_MABX_P.Unit_Delay_53_InitialCondition;

    L4_MABX_DW.Unit_Delay_54_DSTATE = L4_MABX_P.Unit_Delay_54_InitialCondition;

    L4_MABX_DW.Unit_Delay_55_DSTATE = L4_MABX_P.Unit_Delay_55_InitialCondition;

    L4_MABX_DW.Unit_Delay_56_DSTATE = L4_MABX_P.Unit_Delay_56_InitialCondition;

    L4_MABX_DW.Unit_Delay_57_DSTATE = L4_MABX_P.Unit_Delay_57_InitialCondition;

    L4_MABX_DW.Unit_Delay_58_DSTATE = L4_MABX_P.Unit_Delay_58_InitialCondition;

    L4_MABX_DW.Unit_Delay_59_DSTATE = L4_MABX_P.Unit_Delay_59_InitialCondition;

    L4_MABX_DW.Unit_Delay_6_DSTATE = L4_MABX_P.Unit_Delay_6_InitialCondition;

    L4_MABX_DW.Unit_Delay_60_DSTATE = L4_MABX_P.Unit_Delay_60_InitialCondition;

    L4_MABX_DW.Unit_Delay_61_DSTATE = L4_MABX_P.Unit_Delay_61_InitialCondition;

    L4_MABX_DW.Unit_Delay_62_DSTATE = L4_MABX_P.Unit_Delay_62_InitialCondition;

    L4_MABX_DW.Unit_Delay_63_DSTATE = L4_MABX_P.Unit_Delay_63_InitialCondition;

    L4_MABX_DW.Unit_Delay_64_DSTATE = L4_MABX_P.Unit_Delay_64_InitialCondition;

    L4_MABX_DW.Unit_Delay_65_DSTATE = L4_MABX_P.Unit_Delay_65_InitialCondition;

    L4_MABX_DW.Unit_Delay_66_DSTATE = L4_MABX_P.Unit_Delay_66_InitialCondition;

    L4_MABX_DW.Unit_Delay_67_DSTATE = L4_MABX_P.Unit_Delay_67_InitialCondition;

    L4_MABX_DW.Unit_Delay_68_DSTATE = L4_MABX_P.Unit_Delay_68_InitialCondition;

    L4_MABX_DW.Unit_Delay_69_DSTATE = L4_MABX_P.Unit_Delay_69_InitialCondition;

    L4_MABX_DW.Unit_Delay_7_DSTATE = L4_MABX_P.Unit_Delay_7_InitialCondition;

    L4_MABX_DW.Unit_Delay_70_DSTATE = L4_MABX_P.Unit_Delay_70_InitialCondition;

    L4_MABX_DW.Unit_Delay_71_DSTATE = L4_MABX_P.Unit_Delay_71_InitialCondition;

    L4_MABX_DW.Unit_Delay_72_DSTATE = L4_MABX_P.Unit_Delay_72_InitialCondition;

    L4_MABX_DW.Unit_Delay_73_DSTATE = L4_MABX_P.Unit_Delay_73_InitialCondition;

    L4_MABX_DW.Unit_Delay_74_DSTATE = L4_MABX_P.Unit_Delay_74_InitialCondition;

    L4_MABX_DW.Unit_Delay_75_DSTATE = L4_MABX_P.Unit_Delay_75_InitialCondition;

    L4_MABX_DW.Unit_Delay_76_DSTATE = L4_MABX_P.Unit_Delay_76_InitialCondition;

    L4_MABX_DW.Unit_Delay_77_DSTATE = L4_MABX_P.Unit_Delay_77_InitialCondition;

    L4_MABX_DW.Unit_Delay_78_DSTATE = L4_MABX_P.Unit_Delay_78_InitialCondition;

    L4_MABX_DW.Unit_Delay_79_DSTATE = L4_MABX_P.Unit_Delay_79_InitialCondition;

    L4_MABX_DW.Unit_Delay_8_DSTATE = L4_MABX_P.Unit_Delay_8_InitialCondition;

    L4_MABX_DW.Unit_Delay_82_DSTATE = L4_MABX_P.Unit_Delay_82_InitialCondition;

    L4_MABX_DW.Unit_Delay_85_DSTATE = L4_MABX_P.Unit_Delay_85_InitialCondition;

    L4_MABX_DW.Unit_Delay_86_DSTATE = L4_MABX_P.Unit_Delay_86_InitialCondition;

    L4_MABX_DW.Unit_Delay_87_DSTATE = L4_MABX_P.Unit_Delay_87_InitialCondition;

    L4_MABX_DW.Unit_Delay_88_DSTATE = L4_MABX_P.Unit_Delay_88_InitialCondition;

    L4_MABX_DW.Unit_Delay_89_DSTATE = L4_MABX_P.Unit_Delay_89_InitialCondition;

    L4_MABX_DW.Unit_Delay_9_DSTATE = L4_MABX_P.Unit_Delay_9_InitialCondition;

    L4_MABX_DW.Unit_Delay_90_DSTATE = L4_MABX_P.Unit_Delay_90_InitialCondition;

    L4_MABX_DW.Unit_Delay_91_DSTATE = L4_MABX_P.Unit_Delay_91_InitialCondition;

    L4_MABX_DW.Unit_Delay_92_DSTATE = L4_MABX_P.Unit_Delay_92_InitialCondition;

    L4_MABX_DW.Unit_Delay_93_DSTATE = L4_MABX_P.Unit_Delay_93_InitialCondition;

    L4_MABX_DW.Unit_Delay_94_DSTATE = L4_MABX_P.Unit_Delay_94_InitialCondition;

    L4_MABX_DW.Unit_Delay_95_DSTATE = L4_MABX_P.Unit_Delay_95_InitialCondition;

    L4_MABX_DW.Unit_Delay_96_DSTATE = L4_MABX_P.Unit_Delay_96_InitialCondition;

    L4_MABX_DW.Unit_Delay_97_DSTATE = L4_MABX_P.Unit_Delay_97_InitialCondition;

    L4_MABX_DW.Unit_Delay_98_DSTATE = L4_MABX_P.Unit_Delay_98_InitialCondition;

    L4_MABX_DW.Unit_Delay_99_DSTATE = L4_MABX_P.Unit_Delay_99_InitialCondition;



    /* InitializeConditions for UnitDelay: '<S655>/Unit_Delay2' */

    L4_MABX_DW.Unit_Delay2_DSTATE_p1 = L4_MABX_P.Unit_Delay2_InitialCondition_m;



    /* InitializeConditions for UnitDelay: '<S655>/Unit_Delay1' */

    L4_MABX_DW.Unit_Delay1_DSTATE_d = L4_MABX_P.Unit_Delay1_InitialCondition_e;



    /* InitializeConditions for UnitDelay: '<S662>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_iv = L4_MABX_P.Unit_Delay_InitialCondition_ki;



    /* InitializeConditions for UnitDelay: '<S753>/Delay Input1' */

    L4_MABX_DW.DelayInput1_DSTATE_l = L4_MABX_P.DetectRisePositive_vinit_f;



    /* InitializeConditions for UnitDelay: '<S754>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_j = L4_MABX_P.UnitDelay_InitialCondition_i;



    /* InitializeConditions for UnitDelay: '<S748>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_cq = L4_MABX_P.UnitDelay_InitialCondition_gz;



    /* InitializeConditions for UnitDelay: '<S752>/Delay Input1' */

    L4_MABX_DW.DelayInput1_DSTATE_c = L4_MABX_P.DetectFallNonpositive_vinit_n;



    /* InitializeConditions for UnitDelay: '<S754>/Unit Delay1' */

    L4_MABX_DW.UnitDelay1_DSTATE_n = L4_MABX_P.UnitDelay1_InitialCondition_pa;



    /* InitializeConditions for UnitDelay: '<S755>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_is = L4_MABX_P.UnitDelay_InitialCondition_n;



    /* InitializeConditions for UnitDelay: '<S755>/Unit Delay1' */

    L4_MABX_DW.UnitDelay1_DSTATE_pn = L4_MABX_P.UnitDelay1_InitialCondition_c;



    /* InitializeConditions for UnitDelay: '<S10>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_do = L4_MABX_P.Unit_Delay_InitialCondition_jp;



    /* SystemInitialize for Enabled SubSystem: '<S503>/AIR1' */

    /* SystemInitialize for Outport: '<S504>/PneumaticSupplyPress' */

    L4_MABX_B.SFunction1_o1_fw = L4_MABX_P.PneumaticSupplyPress_Y0;



    /* SystemInitialize for Outport: '<S504>/ParkingAnd_orTrailerAirPress' */

    L4_MABX_B.SFunction1_o2_ey = L4_MABX_P.ParkingAnd_orTrailerAirPress_Y0;



    /* SystemInitialize for Outport: '<S504>/ServiceBrakeCircuit1AirPress' */

    L4_MABX_B.SFunction1_o3_j1 = L4_MABX_P.ServiceBrakeCircuit1AirPress_Y0;



    /* SystemInitialize for Outport: '<S504>/ServiceBrakeCircuit2AirPress' */

    L4_MABX_B.SFunction1_o4_kv = L4_MABX_P.ServiceBrakeCircuit2AirPress_Y0;



    /* SystemInitialize for Outport: '<S504>/AuxEquipmentSupplyPress' */

    L4_MABX_B.SFunction1_o5_ki = L4_MABX_P.AuxEquipmentSupplyPress_Y0;



    /* SystemInitialize for Outport: '<S504>/AirSuspensionSupplyPress' */

    L4_MABX_B.SFunction1_o6_jl = L4_MABX_P.AirSuspensionSupplyPress_Y0;



    /* SystemInitialize for Outport: '<S504>/AirCompressorStatus' */

    L4_MABX_B.SFunction1_o7_hj = L4_MABX_P.AirCompressorStatus_Y0;



    /* SystemInitialize for Outport: '<S504>/PowertrainCircuitAirSupplyPress' */

    L4_MABX_B.SFunction1_o8_fg = L4_MABX_P.PowertrainCircuitAirSupplyPress;



    /* SystemInitialize for Outport: '<S504>/RX status' */

    L4_MABX_B.SFunction1_o9_kh = L4_MABX_P.RXstatus_Y0_l;



    /* SystemInitialize for Outport: '<S504>/RX time' */

    L4_MABX_B.SFunction1_o10_dt = L4_MABX_P.RXtime_Y0_n5b;



    /* SystemInitialize for Outport: '<S504>/RX delta time' */

    L4_MABX_B.SFunction1_o11_a3 = L4_MABX_P.RXdeltatime_Y0_p;



    /* End of SystemInitialize for SubSystem: '<S503>/AIR1' */



    /* SystemInitialize for Enabled SubSystem: '<S505>/AMB' */

    /* SystemInitialize for Outport: '<S506>/BarometricPress' */

    L4_MABX_B.SFunction1_o1_a5 = L4_MABX_P.BarometricPress_Y0;



    /* SystemInitialize for Outport: '<S506>/CabInteriorTemp' */

    L4_MABX_B.SFunction1_o2_f2 = L4_MABX_P.CabInteriorTemp_Y0;



    /* SystemInitialize for Outport: '<S506>/AmbientAirTemp' */

    L4_MABX_B.SFunction1_o3_fp = L4_MABX_P.AmbientAirTemp_Y0;



    /* SystemInitialize for Outport: '<S506>/EngAirIntakeTemp' */

    L4_MABX_B.SFunction1_o4_i0 = L4_MABX_P.EngAirIntakeTemp_Y0;



    /* SystemInitialize for Outport: '<S506>/RoadSurfaceTemp' */

    L4_MABX_B.SFunction1_o5_gk = L4_MABX_P.RoadSurfaceTemp_Y0;



    /* SystemInitialize for Outport: '<S506>/RX status' */

    L4_MABX_B.SFunction1_o6_j0 = L4_MABX_P.RXstatus_Y0_f;



    /* SystemInitialize for Outport: '<S506>/RX time' */

    L4_MABX_B.SFunction1_o7_m = L4_MABX_P.RXtime_Y0_i;



    /* SystemInitialize for Outport: '<S506>/RX delta time' */

    L4_MABX_B.SFunction1_o8_i = L4_MABX_P.RXdeltatime_Y0_ez;



    /* End of SystemInitialize for SubSystem: '<S505>/AMB' */



    /* SystemInitialize for Atomic SubSystem: '<S855>/CAN_TX_1000ms' */

    /* SystemInitialize for Enabled SubSystem: '<S875>/AIR1' */

    /* SystemInitialize for Outport: '<S876>/TX status' */

    L4_MABX_B.SFunction1_o1_bs = L4_MABX_P.TXstatus_Y0;



    /* SystemInitialize for Outport: '<S876>/TX time' */

    L4_MABX_B.SFunction1_o2_ad = L4_MABX_P.TXtime_Y0;



    /* SystemInitialize for Outport: '<S876>/TX delta time' */

    L4_MABX_B.SFunction1_o3_dz = L4_MABX_P.TXdeltatime_Y0;



    /* SystemInitialize for Outport: '<S876>/TX delay time' */

    L4_MABX_B.SFunction1_o4_hw = L4_MABX_P.TXdelaytime_Y0;



    /* End of SystemInitialize for SubSystem: '<S875>/AIR1' */



    /* SystemInitialize for Enabled SubSystem: '<S883>/AMB' */

    /* SystemInitialize for Outport: '<S884>/TX status' */

    L4_MABX_B.SFunction1_o1_lt = L4_MABX_P.TXstatus_Y0_k;



    /* SystemInitialize for Outport: '<S884>/TX time' */

    L4_MABX_B.SFunction1_o2_n = L4_MABX_P.TXtime_Y0_c;



    /* SystemInitialize for Outport: '<S884>/TX delta time' */

    L4_MABX_B.SFunction1_o3_ea = L4_MABX_P.TXdeltatime_Y0_i;



    /* SystemInitialize for Outport: '<S884>/TX delay time' */

    L4_MABX_B.SFunction1_o4_d0 = L4_MABX_P.TXdelaytime_Y0_g;



    /* End of SystemInitialize for SubSystem: '<S883>/AMB' */

    /* End of SystemInitialize for SubSystem: '<S855>/CAN_TX_1000ms' */



    /* SystemInitialize for Chart: '<S851>/Chart' */

    L4_MABX_DW.is_active_c5_SUB_ECU_L4_MABX_HW = 0U;

    L4_MABX_DW.is_c5_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_NO_ACTIVE_CHILD;



    /* SystemInitialize for Chart: '<S769>/Health State Machine PWM Sensor 1' */

    L4_MABX_DW.is_FAILURE_DETECTED_b = L4_MABX_IN_NO_ACTIVE_CHILD;

    L4_MABX_DW.is_active_c9_SUB_ECU_L4_MABX_HW = 0U;

    L4_MABX_DW.is_c9_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_NO_ACTIVE_CHILD;



    /* SystemInitialize for Chart: '<S769>/Health State Machine PWM Sensor 2' */

    L4_MABX_DW.is_FAILURE_DETECTED = L4_MABX_IN_NO_ACTIVE_CHILD;

    L4_MABX_DW.is_active_c10_SUB_ECU_L4_MABX_H = 0U;

    L4_MABX_DW.is_c10_SUB_ECU_L4_MABX_HW_Inter = L4_MABX_IN_NO_ACTIVE_CHILD;



    /* SystemInitialize for Enabled SubSystem: '<S750>/Slew_at_event' */

    /* InitializeConditions for UnitDelay: '<S844>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_jr = L4_MABX_P.Unit_Delay_InitialCondition_e2j;



    /* InitializeConditions for UnitDelay: '<S845>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_jz = L4_MABX_P.Unit_Delay_InitialCondition_g1;



    /* InitializeConditions for UnitDelay: '<S848>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_b =

      L4_MABX_P.FixPtUnitDelay2_InitialCondi_a4;



    /* InitializeConditions for UnitDelay: '<S848>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_o =

      L4_MABX_P.FixPtUnitDelay1_InitialCondit_i;



    /* InitializeConditions for UnitDelay: '<S843>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_hg = L4_MABX_P.Unit_Delay_InitialCondition_nk;



    /* SystemInitialize for Outport: '<S773>/F_Out_slewing' */

    L4_MABX_B.LogicalOperator_np = L4_MABX_P.F_Out_slewing_Y0_a;



    /* SystemInitialize for Outport: '<S773>/Out' */

    L4_MABX_B.If_Then_Else_or.Switch = L4_MABX_P.Out_Y0_h;



    /* End of SystemInitialize for SubSystem: '<S750>/Slew_at_event' */



    /* SystemInitialize for Enabled SubSystem: '<S513>/CCVS1_31' */

    /* SystemInitialize for Outport: '<S514>/TwoSpeedAxleSwitch' */

    L4_MABX_B.SFunction1_o1_kp = L4_MABX_P.TwoSpeedAxleSwitch_Y0_a;



    /* SystemInitialize for Outport: '<S514>/ParkingBrakeSwitch' */

    L4_MABX_B.SFunction1_o2_bl = L4_MABX_P.ParkingBrakeSwitch_Y0_e;



    /* SystemInitialize for Outport: '<S514>/CruiseCtrlPauseSwitch' */

    L4_MABX_B.SFunction1_o3_g2 = L4_MABX_P.CruiseCtrlPauseSwitch_Y0_e;



    /* SystemInitialize for Outport: '<S514>/ParkBrakeReleaseInhibitRq' */

    L4_MABX_B.SFunction1_o4_bx = L4_MABX_P.ParkBrakeReleaseInhibitRq_Y0_n;



    /* SystemInitialize for Outport: '<S514>/WheelBasedVehicleSpeed' */

    L4_MABX_B.SFunction1_o5_p1 = L4_MABX_P.WheelBasedVehicleSpeed_Y0_i;



    /* SystemInitialize for Outport: '<S514>/CruiseCtrlActive' */

    L4_MABX_B.SFunction1_o6_pt = L4_MABX_P.CruiseCtrlActive_Y0_j;



    /* SystemInitialize for Outport: '<S514>/CruiseCtrlEnableSwitch' */

    L4_MABX_B.SFunction1_o7_g = L4_MABX_P.CruiseCtrlEnableSwitch_Y0_c;



    /* SystemInitialize for Outport: '<S514>/BrakeSwitch' */

    L4_MABX_B.SFunction1_o8_fp = L4_MABX_P.BrakeSwitch_Y0_a;



    /* SystemInitialize for Outport: '<S514>/ClutchSwitch' */

    L4_MABX_B.SFunction1_o9_gg = L4_MABX_P.ClutchSwitch_Y0_n;



    /* SystemInitialize for Outport: '<S514>/CruiseCtrlSetSwitch' */

    L4_MABX_B.SFunction1_o10_cf = L4_MABX_P.CruiseCtrlSetSwitch_Y0_k;



    /* SystemInitialize for Outport: '<S514>/CruiseCtrlCoastSwitch' */

    L4_MABX_B.SFunction1_o11_dy = L4_MABX_P.CruiseCtrlCoastSwitch_Y0_c;



    /* SystemInitialize for Outport: '<S514>/CruiseCtrlResumeSwitch' */

    L4_MABX_B.SFunction1_o12_j = L4_MABX_P.CruiseCtrlResumeSwitch_Y0_n;



    /* SystemInitialize for Outport: '<S514>/CruiseCtrlAccelerateSwitch' */

    L4_MABX_B.SFunction1_o13_og = L4_MABX_P.CruiseCtrlAccelerateSwitch_Y0_e;



    /* SystemInitialize for Outport: '<S514>/CruiseCtrlSetSpeed' */

    L4_MABX_B.SFunction1_o14_p = L4_MABX_P.CruiseCtrlSetSpeed_Y0_n;



    /* SystemInitialize for Outport: '<S514>/PTOGovernorState' */

    L4_MABX_B.SFunction1_o15_h = L4_MABX_P.PTOGovernorState_Y0_i;



    /* SystemInitialize for Outport: '<S514>/CruiseCtrlStates' */

    L4_MABX_B.SFunction1_o16_m = L4_MABX_P.CruiseCtrlStates_Y0_k;



    /* SystemInitialize for Outport: '<S514>/EngIdleIncrementSwitch' */

    L4_MABX_B.SFunction1_o17_k = L4_MABX_P.EngIdleIncrementSwitch_Y0_i;



    /* SystemInitialize for Outport: '<S514>/EngIdleDecrementSwitch' */

    L4_MABX_B.SFunction1_o18_a = L4_MABX_P.EngIdleDecrementSwitch_Y0_i;



    /* SystemInitialize for Outport: '<S514>/EngTestModeSwitch' */

    L4_MABX_B.SFunction1_o19_i = L4_MABX_P.EngTestModeSwitch_Y0_m;



    /* SystemInitialize for Outport: '<S514>/EngShutdownOverrideSwitch' */

    L4_MABX_B.SFunction1_o20_i = L4_MABX_P.EngShutdownOverrideSwitch_Y0_b;



    /* SystemInitialize for Outport: '<S514>/RX status' */

    L4_MABX_B.SFunction1_o21_e = L4_MABX_P.RXstatus_Y0_e;



    /* SystemInitialize for Outport: '<S514>/RX time' */

    L4_MABX_B.SFunction1_o22_ih = L4_MABX_P.RXtime_Y0_l;



    /* SystemInitialize for Outport: '<S514>/RX delta time' */

    L4_MABX_B.SFunction1_o23_i = L4_MABX_P.RXdeltatime_Y0_n;



    /* End of SystemInitialize for SubSystem: '<S513>/CCVS1_31' */



    /* SystemInitialize for Enabled SubSystem: '<S524>/EBC2_0B1' */

    /* SystemInitialize for Outport: '<S525>/FrontAxleSpeed' */

    L4_MABX_B.SFunction1_o1_gd = L4_MABX_P.FrontAxleSpeed_Y0;



    /* SystemInitialize for Outport: '<S525>/RelativeSpeedFrontAxleLeftWheel' */

    L4_MABX_B.SFunction1_o2_dl = L4_MABX_P.RelativeSpeedFrontAxleLeftWheel;



    /* SystemInitialize for Outport: '<S525>/RlativeSpeedFrontAxleRightWheel' */

    L4_MABX_B.SFunction1_o3_hh = L4_MABX_P.RlativeSpeedFrontAxleRightWheel;



    /* SystemInitialize for Outport: '<S525>/RelativeSpeedRearAxle1LeftWheel' */

    L4_MABX_B.SFunction1_o4_cs = L4_MABX_P.RelativeSpeedRearAxle1LeftWheel;



    /* SystemInitialize for Outport: '<S525>/RlativeSpeedRearAxle1RightWheel' */

    L4_MABX_B.SFunction1_o5_o = L4_MABX_P.RlativeSpeedRearAxle1RightWheel;



    /* SystemInitialize for Outport: '<S525>/RelativeSpeedRearAxle2LeftWheel' */

    L4_MABX_B.SFunction1_o6_la = L4_MABX_P.RelativeSpeedRearAxle2LeftWheel;



    /* SystemInitialize for Outport: '<S525>/RlativeSpeedRearAxle2RightWheel' */

    L4_MABX_B.SFunction1_o7_lp = L4_MABX_P.RlativeSpeedRearAxle2RightWheel;



    /* SystemInitialize for Outport: '<S525>/RX status' */

    L4_MABX_B.SFunction1_o8_bo = L4_MABX_P.RXstatus_Y0_k0;



    /* SystemInitialize for Outport: '<S525>/RX time' */

    L4_MABX_B.SFunction1_o9_a = L4_MABX_P.RXtime_Y0_m;



    /* SystemInitialize for Outport: '<S525>/RX delta time' */

    L4_MABX_B.SFunction1_o10_pk = L4_MABX_P.RXdeltatime_Y0_kr;



    /* End of SystemInitialize for SubSystem: '<S524>/EBC2_0B1' */



    /* SystemInitialize for Enabled SubSystem: '<S582>/HRW_0B' */

    /* SystemInitialize for Outport: '<S583>/FrontAxleLeftWheelSpeed' */

    L4_MABX_B.SFunction1_o1_au = L4_MABX_P.FrontAxleLeftWheelSpeed_Y0;



    /* SystemInitialize for Outport: '<S583>/FrontAxleRightWheelSpeed' */

    L4_MABX_B.SFunction1_o2_hu = L4_MABX_P.FrontAxleRightWheelSpeed_Y0;



    /* SystemInitialize for Outport: '<S583>/RearAxleLeftWheelSpeed' */

    L4_MABX_B.SFunction1_o3_pw = L4_MABX_P.RearAxleLeftWheelSpeed_Y0;



    /* SystemInitialize for Outport: '<S583>/RearAxleRightWheelSpeed' */

    L4_MABX_B.SFunction1_o4_auj = L4_MABX_P.RearAxleRightWheelSpeed_Y0;



    /* SystemInitialize for Outport: '<S583>/RX status' */

    L4_MABX_B.SFunction1_o5_ij = L4_MABX_P.RXstatus_Y0_ef;



    /* SystemInitialize for Outport: '<S583>/RX time' */

    L4_MABX_B.SFunction1_o6_kk = L4_MABX_P.RXtime_Y0_m0;



    /* SystemInitialize for Outport: '<S583>/RX delta time' */

    L4_MABX_B.SFunction1_o7_cp = L4_MABX_P.RXdeltatime_Y0_ph;



    /* End of SystemInitialize for SubSystem: '<S582>/HRW_0B' */



    /* SystemInitialize for Enabled SubSystem: '<S522>/EBC1_0B' */

    /* SystemInitialize for Outport: '<S523>/ASREngCtrlActive' */

    L4_MABX_B.SFunction1_o1_df = L4_MABX_P.ASREngCtrlActive_Y0_c;



    /* SystemInitialize for Outport: '<S523>/ASRBrakeCtrlActive' */

    L4_MABX_B.SFunction1_o2_eb = L4_MABX_P.ASRBrakeCtrlActive_Y0_p;



    /* SystemInitialize for Outport: '<S523>/AntiLockBrakingActive' */

    L4_MABX_B.SFunction1_o3_kb = L4_MABX_P.AntiLockBrakingActive_Y0_m;



    /* SystemInitialize for Outport: '<S523>/EBSBrakeSwitch' */

    L4_MABX_B.SFunction1_o4_nj = L4_MABX_P.EBSBrakeSwitch_Y0_p;



    /* SystemInitialize for Outport: '<S523>/BrakePedalPos' */

    L4_MABX_B.SFunction1_o5_k3 = L4_MABX_P.BrakePedalPos_Y0_j;



    /* SystemInitialize for Outport: '<S523>/ABSOffroadSwitch' */

    L4_MABX_B.SFunction1_o6_hu = L4_MABX_P.ABSOffroadSwitch_Y0_d;



    /* SystemInitialize for Outport: '<S523>/ASROffroadSwitch' */

    L4_MABX_B.SFunction1_o7_k = L4_MABX_P.ASROffroadSwitch_Y0_c;



    /* SystemInitialize for Outport: '<S523>/ASRHillHolderSwitch' */

    L4_MABX_B.SFunction1_o8_lb = L4_MABX_P.ASRHillHolderSwitch_Y0_h;



    /* SystemInitialize for Outport: '<S523>/TractionCtrlOverrideSwitch' */

    L4_MABX_B.SFunction1_o9_oz = L4_MABX_P.TractionCtrlOverrideSwitch_Y0_c;



    /* SystemInitialize for Outport: '<S523>/AccelInterlockSwitch' */

    L4_MABX_B.SFunction1_o10_dd = L4_MABX_P.AccelInterlockSwitch_Y0_h;



    /* SystemInitialize for Outport: '<S523>/EngDerateSwitch' */

    L4_MABX_B.SFunction1_o11_a2 = L4_MABX_P.EngDerateSwitch_Y0_m;



    /* SystemInitialize for Outport: '<S523>/EngAuxShutdownSwitch' */

    L4_MABX_B.SFunction1_o12_c = L4_MABX_P.EngAuxShutdownSwitch_Y0_l;



    /* SystemInitialize for Outport: '<S523>/RemoteAccelEnableSwitch' */

    L4_MABX_B.SFunction1_o13_o = L4_MABX_P.RemoteAccelEnableSwitch_Y0_g;



    /* SystemInitialize for Outport: '<S523>/EngRetarderSelection' */

    L4_MABX_B.SFunction1_o14_l = L4_MABX_P.EngRetarderSelection_Y0_b;



    /* SystemInitialize for Outport: '<S523>/ABSFullyOperational' */

    L4_MABX_B.SFunction1_o15_a = L4_MABX_P.ABSFullyOperational_Y0_o;



    /* SystemInitialize for Outport: '<S523>/EBSRedWarningSignal' */

    L4_MABX_B.SFunction1_o16_ed = L4_MABX_P.EBSRedWarningSignal_Y0_i;



    /* SystemInitialize for Outport: '<S523>/ABS_EBSAmberWarningSignal' */

    L4_MABX_B.SFunction1_o17_d = L4_MABX_P.ABS_EBSAmberWarningSignal_Y0_p;



    /* SystemInitialize for Outport: '<S523>/ATC_ASRInformationSignal' */

    L4_MABX_B.SFunction1_o18_c = L4_MABX_P.ATC_ASRInformationSignal_Y0_h;



    /* SystemInitialize for Outport: '<S523>/SrcAddrssOfCtrllngDvcFrBrkCntrl' */

    L4_MABX_B.SFunction1_o19_o = L4_MABX_P.SrcAddrssOfCtrllngDvcFrBrkCnt_i;



    /* SystemInitialize for Outport: '<S523>/HaltBrakeSwitch' */

    L4_MABX_B.SFunction1_o20_e = L4_MABX_P.HaltBrakeSwitch_Y0_e;



    /* SystemInitialize for Outport: '<S523>/TrailerABSStatus' */

    L4_MABX_B.SFunction1_o21_f = L4_MABX_P.TrailerABSStatus_Y0_l;



    /* SystemInitialize for Outport: '<S523>/TrctrMntdTrilerABSWarningSignal' */

    L4_MABX_B.SFunction1_o22_o = L4_MABX_P.TrctrMntdTrilerABSWarningSign_f;



    /* SystemInitialize for Outport: '<S523>/RX status' */

    L4_MABX_B.SFunction1_o23_b = L4_MABX_P.RXstatus_Y0_ei;



    /* SystemInitialize for Outport: '<S523>/RX time' */

    L4_MABX_B.SFunction1_o24_l = L4_MABX_P.RXtime_Y0_de;



    /* SystemInitialize for Outport: '<S523>/RX delta time' */

    L4_MABX_B.SFunction1_o25_p = L4_MABX_P.RXdeltatime_Y0_g;



    /* End of SystemInitialize for SubSystem: '<S522>/EBC1_0B' */



    /* SystemInitialize for Enabled SubSystem: '<S577>/ETC2_031' */

    /* SystemInitialize for Outport: '<S578>/SPN524_TransSelectedGear' */

    L4_MABX_B.SFunction1_o1_nm = L4_MABX_P.SPN524_TransSelectedGear_Y0;



    /* SystemInitialize for Outport: '<S578>/SPN526_TransActualGearRatio' */

    L4_MABX_B.SFunction1_o2_mp = L4_MABX_P.SPN526_TransActualGearRatio_Y0;



    /* SystemInitialize for Outport: '<S578>/SPN523_TransCurrentGear' */

    L4_MABX_B.SFunction1_o3_cn = L4_MABX_P.SPN523_TransCurrentGear_Y0;



    /* SystemInitialize for Outport: '<S578>/RX status' */

    L4_MABX_B.SFunction1_o4_ly = L4_MABX_P.RXstatus_Y0_me;



    /* SystemInitialize for Outport: '<S578>/RX time' */

    L4_MABX_B.SFunction1_o5_e3 = L4_MABX_P.RXtime_Y0_h2;



    /* SystemInitialize for Outport: '<S578>/RX delta time' */

    L4_MABX_B.SFunction1_o6_o = L4_MABX_P.RXdeltatime_Y0_a;



    /* End of SystemInitialize for SubSystem: '<S577>/ETC2_031' */



    /* SystemInitialize for Enabled SubSystem: '<S571>/EEC1_001' */

    /* SystemInitialize for Outport: '<S572>/EngTorqueMode' */

    L4_MABX_B.SFunction1_o1_nr = L4_MABX_P.EngTorqueMode_Y0;



    /* SystemInitialize for Outport: '<S572>/ActlEngPrcntTrqueHighResolution' */

    L4_MABX_B.SFunction1_o2_dgu = L4_MABX_P.ActlEngPrcntTrqueHighResolution;



    /* SystemInitialize for Outport: '<S572>/DriversDemandEngPercentTorque' */

    L4_MABX_B.SFunction1_o3_ho = L4_MABX_P.DriversDemandEngPercentTorque_Y;



    /* SystemInitialize for Outport: '<S572>/ActualEngPercentTorque' */

    L4_MABX_B.SFunction1_o4_ki = L4_MABX_P.ActualEngPercentTorque_Y0;



    /* SystemInitialize for Outport: '<S572>/EngSpeed' */

    L4_MABX_B.SFunction1_o5_nl = L4_MABX_P.EngSpeed_Y0;



    /* SystemInitialize for Outport: '<S572>/SrcAddrssOfCtrllngDvcFrEngCntrl' */

    L4_MABX_B.SFunction1_o6_hc = L4_MABX_P.SrcAddrssOfCtrllngDvcFrEngCntrl;



    /* SystemInitialize for Outport: '<S572>/EngStarterMode' */

    L4_MABX_B.SFunction1_o7_ln = L4_MABX_P.EngStarterMode_Y0;



    /* SystemInitialize for Outport: '<S572>/EngDemandPercentTorque' */

    L4_MABX_B.SFunction1_o8_f = L4_MABX_P.EngDemandPercentTorque_Y0;



    /* SystemInitialize for Outport: '<S572>/RX status' */

    L4_MABX_B.SFunction1_o9_gn = L4_MABX_P.RXstatus_Y0_n;



    /* SystemInitialize for Outport: '<S572>/RX time' */

    L4_MABX_B.SFunction1_o10_b = L4_MABX_P.RXtime_Y0_lm;



    /* SystemInitialize for Outport: '<S572>/RX delta time' */

    L4_MABX_B.SFunction1_o11_b = L4_MABX_P.RXdeltatime_Y0_ky;



    /* End of SystemInitialize for SubSystem: '<S571>/EEC1_001' */



    /* SystemInitialize for Enabled SubSystem: '<S575>/EEC3_001' */

    /* SystemInitialize for Outport: '<S576>/SPN514_NominalFrictionPercentTorque' */

    L4_MABX_B.SFunction1_o1_g = L4_MABX_P.SPN514_NominalFrictionPercentTo;



    /* SystemInitialize for Outport: '<S576>/SPN2978_EstEngParasiticLossesPercentTorque' */

    L4_MABX_B.SFunction1_o2_ky = L4_MABX_P.SPN2978_EstEngParasiticLossesPe;



    /* SystemInitialize for Outport: '<S576>/RX status' */

    L4_MABX_B.SFunction1_o3_fy = L4_MABX_P.RXstatus_Y0_n5;



    /* SystemInitialize for Outport: '<S576>/RX time' */

    L4_MABX_B.SFunction1_o4_lo = L4_MABX_P.RXtime_Y0_l3;



    /* SystemInitialize for Outport: '<S576>/RX delta time' */

    L4_MABX_B.SFunction1_o5_jl = L4_MABX_P.RXdeltatime_Y0_e3;



    /* End of SystemInitialize for SubSystem: '<S575>/EEC3_001' */



    /* SystemInitialize for Enabled SubSystem: '<S518>/CVW_0B1' */

    /* SystemInitialize for Outport: '<S519>/SPN1760_GrossCombinationVehicleWeight' */

    L4_MABX_B.SFunction1_o1_kzx = L4_MABX_P.SPN1760_GrossCombinationVehicle;



    /* SystemInitialize for Outport: '<S519>/RX status' */

    L4_MABX_B.SFunction1_o2_bq = L4_MABX_P.RXstatus_Y0_ge;



    /* SystemInitialize for Outport: '<S519>/RX time' */

    L4_MABX_B.SFunction1_o3_dd = L4_MABX_P.RXtime_Y0_j;



    /* SystemInitialize for Outport: '<S519>/RX delta time' */

    L4_MABX_B.SFunction1_o4_ha = L4_MABX_P.RXdeltatime_Y0_d1;



    /* End of SystemInitialize for SubSystem: '<S518>/CVW_0B1' */



    /* SystemInitialize for Enabled SubSystem: '<S499>/ACC1_2A_' */

    /* SystemInitialize for Outport: '<S500>/SpeedOfForwardVehicle' */

    L4_MABX_B.SFunction1_o1_de = L4_MABX_P.SpeedOfForwardVehicle_Y0;



    /* SystemInitialize for Outport: '<S500>/DistanceToForwardVehicle' */

    L4_MABX_B.SFunction1_o2_d5 = L4_MABX_P.DistanceToForwardVehicle_Y0;



    /* SystemInitialize for Outport: '<S500>/AdaptiveCruiseCtrlSetSpeed' */

    L4_MABX_B.SFunction1_o3_dg = L4_MABX_P.AdaptiveCruiseCtrlSetSpeed_Y0;



    /* SystemInitialize for Outport: '<S500>/AdaptiveCruiseCtrlMode' */

    L4_MABX_B.SFunction1_o4_bc = L4_MABX_P.AdaptiveCruiseCtrlMode_Y0;



    /* SystemInitialize for Outport: '<S500>/AdptveCruiseCtrlSetDistanceMode' */

    L4_MABX_B.SFunction1_o5_k4 = L4_MABX_P.AdptveCruiseCtrlSetDistanceMode;



    /* SystemInitialize for Outport: '<S500>/RoadCurvature' */

    L4_MABX_B.SFunction1_o6_j5 = L4_MABX_P.RoadCurvature_Y0;



    /* SystemInitialize for Outport: '<S500>/ACCTargetDetected' */

    L4_MABX_B.SFunction1_o7_hh = L4_MABX_P.ACCTargetDetected_Y0;



    /* SystemInitialize for Outport: '<S500>/ACCSystemShutoffWarning' */

    L4_MABX_B.SFunction1_o8_oi = L4_MABX_P.ACCSystemShutoffWarning_Y0;



    /* SystemInitialize for Outport: '<S500>/ACCDistanceAlertSignal' */

    L4_MABX_B.SFunction1_o9_ih = L4_MABX_P.ACCDistanceAlertSignal_Y0;



    /* SystemInitialize for Outport: '<S500>/ForwardCollisionWarning' */

    L4_MABX_B.SFunction1_o10_py = L4_MABX_P.ForwardCollisionWarning_Y0;



    /* SystemInitialize for Outport: '<S500>/RX status' */

    L4_MABX_B.SFunction1_o11_mg = L4_MABX_P.RXstatus_Y0_k;



    /* SystemInitialize for Outport: '<S500>/RX time' */

    L4_MABX_B.SFunction1_o12_n = L4_MABX_P.RXtime_Y0_d;



    /* SystemInitialize for Outport: '<S500>/RX delta time' */

    L4_MABX_B.SFunction1_o13_or = L4_MABX_P.RXdeltatime_Y0_k;



    /* End of SystemInitialize for SubSystem: '<S499>/ACC1_2A_' */



    /* SystemInitialize for Enabled SubSystem: '<S481>/CAN_TYPE1_RX_M1_C1' */

    /* SystemInitialize for Outport: '<S483>/byte1' */

    L4_MABX_B.SFunction1_o1_bv = L4_MABX_P.byte1_Y0;



    /* SystemInitialize for Outport: '<S483>/byte2' */

    L4_MABX_B.SFunction1_o2_kv = L4_MABX_P.byte2_Y0;



    /* SystemInitialize for Outport: '<S483>/byte3' */

    L4_MABX_B.SFunction1_o3_j2 = L4_MABX_P.byte3_Y0;



    /* SystemInitialize for Outport: '<S483>/byte4' */

    L4_MABX_B.SFunction1_o4_fp = L4_MABX_P.byte4_Y0;



    /* SystemInitialize for Outport: '<S483>/byte5' */

    L4_MABX_B.SFunction1_o5_mi = L4_MABX_P.byte5_Y0;



    /* SystemInitialize for Outport: '<S483>/byte6' */

    L4_MABX_B.SFunction1_o6_kp = L4_MABX_P.byte6_Y0;



    /* SystemInitialize for Outport: '<S483>/byte7' */

    L4_MABX_B.SFunction1_o7_gb = L4_MABX_P.byte7_Y0;



    /* SystemInitialize for Outport: '<S483>/byte8' */

    L4_MABX_B.SFunction1_o8_ez = L4_MABX_P.byte8_Y0;



    /* SystemInitialize for Outport: '<S483>/RX status' */

    L4_MABX_B.SFunction1_o9_ad = L4_MABX_P.RXstatus_Y0;



    /* SystemInitialize for Outport: '<S483>/RX time' */

    L4_MABX_B.SFunction1_o10_n = L4_MABX_P.RXtime_Y0;



    /* SystemInitialize for Outport: '<S483>/RX delta time' */

    L4_MABX_B.SFunction1_o11_p = L4_MABX_P.RXdeltatime_Y0;



    /* End of SystemInitialize for SubSystem: '<S481>/CAN_TYPE1_RX_M1_C1' */



    /* SystemInitialize for Enabled SubSystem: '<S475>/Decode_TPCM_BAM' */

    /* SystemInitialize for Outport: '<S693>/Out' */

    L4_MABX_B.SPN2556_ControlByte_n = (uint8_T)L4_MABX_P.Out_Y0_f;

    L4_MABX_B.DataType_h1 = (uint16_T)L4_MABX_P.Out_Y0_f;

    L4_MABX_B.SPN2568_TotalNumberOfPackets = (uint8_T)L4_MABX_P.Out_Y0_f;

    L4_MABX_B.DataType_jy = (uint32_T)L4_MABX_P.Out_Y0_f;



    /* End of SystemInitialize for SubSystem: '<S475>/Decode_TPCM_BAM' */



    /* SystemInitialize for Enabled SubSystem: '<S490>/CAN_TYPE1_RX_M1_C1' */

    /* SystemInitialize for Outport: '<S492>/byte1' */

    L4_MABX_B.SFunction1_o1_jh = L4_MABX_P.byte1_Y0_d;



    /* SystemInitialize for Outport: '<S492>/byte2' */

    L4_MABX_B.SFunction1_o2_e2 = L4_MABX_P.byte2_Y0_d;



    /* SystemInitialize for Outport: '<S492>/byte3' */

    L4_MABX_B.SFunction1_o3_id = L4_MABX_P.byte3_Y0_e;



    /* SystemInitialize for Outport: '<S492>/byte4' */

    L4_MABX_B.SFunction1_o4_jm = L4_MABX_P.byte4_Y0_k;



    /* SystemInitialize for Outport: '<S492>/byte5' */

    L4_MABX_B.SFunction1_o5_h = L4_MABX_P.byte5_Y0_l;



    /* SystemInitialize for Outport: '<S492>/byte6' */

    L4_MABX_B.SFunction1_o6_c = L4_MABX_P.byte6_Y0_n;



    /* SystemInitialize for Outport: '<S492>/byte7' */

    L4_MABX_B.SFunction1_o7_dv = L4_MABX_P.byte7_Y0_n;



    /* SystemInitialize for Outport: '<S492>/byte8' */

    L4_MABX_B.SFunction1_o8_of = L4_MABX_P.byte8_Y0_n;



    /* SystemInitialize for Outport: '<S492>/RX status' */

    L4_MABX_B.SFunction1_o9_dt = L4_MABX_P.RXstatus_Y0_g;



    /* SystemInitialize for Outport: '<S492>/RX time' */

    L4_MABX_B.SFunction1_o10_hj = L4_MABX_P.RXtime_Y0_n;



    /* SystemInitialize for Outport: '<S492>/RX delta time' */

    L4_MABX_B.SFunction1_o11_h = L4_MABX_P.RXdeltatime_Y0_e;



    /* End of SystemInitialize for SubSystem: '<S490>/CAN_TYPE1_RX_M1_C1' */



    /* SystemInitialize for S-Function (rti_commonblock): '<S854>/S-Function1' incorporates:

     *  SubSystem: '<S423>/IncrementTimer'

     */

    L4_MABX_IncrementTimer_Init();



    /* End of SystemInitialize for S-Function (rti_commonblock): '<S854>/S-Function1' */



    /* SystemInitialize for Enabled SubSystem: '<S442>/CAN_RX_EC1_00' */

    /* SystemInitialize for Enabled SubSystem: '<S526>/Decode' */

    /* InitializeConditions for UnitDelay: '<S529>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_i = L4_MABX_P.Unit_Delay_InitialCondition_o;

    for (i = 0; i < 39; i++) {

      /* InitializeConditions for UnitDelay: '<S526>/Unit Delay' */

      L4_MABX_DW.UnitDelay_DSTATE_b3[i] =

        L4_MABX_P.UnitDelay_InitialCondition_j2[i];



      /* SystemInitialize for Outport: '<S529>/RawData' */

      L4_MABX_B.Inport_b[i] = L4_MABX_P.RawData_Y0;

    }



    /* SystemInitialize for Outport: '<S529>/RX_time' */

    L4_MABX_B.timeStamp_j = L4_MABX_P.RX_time_Y0;



    /* SystemInitialize for Outport: '<S529>/RX_delta_time' */

    L4_MABX_B.Subtract_gi = L4_MABX_P.RX_delta_time_Y0;



    /* End of SystemInitialize for SubSystem: '<S526>/Decode' */



    /* SystemInitialize for Outport: '<S526>/RX_status' */

    L4_MABX_B.RX_status_pz = L4_MABX_P.RX_status_Y0;



    /* End of SystemInitialize for SubSystem: '<S442>/CAN_RX_EC1_00' */



    /* SystemInitialize for Enabled SubSystem: '<S648>/VDC1_0B_' */

    /* SystemInitialize for Outport: '<S649>/VDCInformationSignal' */

    L4_MABX_B.SFunction1_o1_n5 = L4_MABX_P.VDCInformationSignal_Y0;



    /* SystemInitialize for Outport: '<S649>/VDCFullyOperational' */

    L4_MABX_B.SFunction1_o2_c5 = L4_MABX_P.VDCFullyOperational_Y0;



    /* SystemInitialize for Outport: '<S649>/VDCBrakeLightRq' */

    L4_MABX_B.SFunction1_o3_e2 = L4_MABX_P.VDCBrakeLightRq_Y0;



    /* SystemInitialize for Outport: '<S649>/ROPEngCtrlActive' */

    L4_MABX_B.SFunction1_o4_lj = L4_MABX_P.ROPEngCtrlActive_Y0;



    /* SystemInitialize for Outport: '<S649>/ROPBrakeCtrlActive' */

    L4_MABX_B.SFunction1_o5_i = L4_MABX_P.ROPBrakeCtrlActive_Y0;



    /* SystemInitialize for Outport: '<S649>/YCEngCtrlActive' */

    L4_MABX_B.SFunction1_o6_d = L4_MABX_P.YCEngCtrlActive_Y0;



    /* SystemInitialize for Outport: '<S649>/YCBrakeCtrlActive' */

    L4_MABX_B.SFunction1_o7_h = L4_MABX_P.YCBrakeCtrlActive_Y0;



    /* SystemInitialize for Outport: '<S649>/RX status' */

    L4_MABX_B.SFunction1_o8_m = L4_MABX_P.RXstatus_Y0_gk;



    /* SystemInitialize for Outport: '<S649>/RX time' */

    L4_MABX_B.SFunction1_o9_m = L4_MABX_P.RXtime_Y0_hl;



    /* SystemInitialize for Outport: '<S649>/RX delta time' */

    L4_MABX_B.SFunction1_o10 = L4_MABX_P.RXdeltatime_Y0_ot;



    /* End of SystemInitialize for SubSystem: '<S648>/VDC1_0B_' */



    /* SystemInitialize for Enabled SubSystem: '<S650>/VDC2_0B1' */

    /* SystemInitialize for Outport: '<S651>/SteerWheelAngle' */

    SteerWheelAngle = L4_MABX_P.SteerWheelAngle_Y0;



    /* SystemInitialize for Outport: '<S651>/SteerWheelTurnCounter' */

    L4_MABX_B.SFunction1_o2_gn = L4_MABX_P.SteerWheelTurnCounter_Y0;



    /* SystemInitialize for Outport: '<S651>/SteerWheelAngleSensorType' */

    L4_MABX_B.SFunction1_o3_jk = L4_MABX_P.SteerWheelAngleSensorType_Y0;



    /* SystemInitialize for Outport: '<S651>/YawRate' */

    YawRate = L4_MABX_P.YawRate_Y0;



    /* SystemInitialize for Outport: '<S651>/LateralAcceleration' */

    L4_MABX_B.SFunction1_o5_f = L4_MABX_P.LateralAcceleration_Y0;



    /* SystemInitialize for Outport: '<S651>/LongitudinalAcceleration' */

    SPN1810_LongitudinalAcceleration = L4_MABX_P.LongitudinalAcceleration_Y0;



    /* SystemInitialize for Outport: '<S651>/RX status' */

    L4_MABX_B.SFunction1_o7_f = L4_MABX_P.RXstatus_Y0_k0m;



    /* SystemInitialize for Outport: '<S651>/RX time' */

    L4_MABX_B.SFunction1_o8_p = L4_MABX_P.RXtime_Y0_jd;



    /* SystemInitialize for Outport: '<S651>/RX delta time' */

    L4_MABX_B.SFunction1_o9 = L4_MABX_P.RXdeltatime_Y0_nx;



    /* End of SystemInitialize for SubSystem: '<S650>/VDC2_0B1' */



    /* SystemInitialize for Enabled SubSystem: '<S465>/CAN_RX_VI_00' */

    /* SystemInitialize for Enabled SubSystem: '<S654>/Decode' */

    /* InitializeConditions for UnitDelay: '<S657>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_d = L4_MABX_P.Unit_Delay_InitialCondition_a;

    for (i = 0; i < 17; i++) {

      /* InitializeConditions for UnitDelay: '<S654>/Unit Delay' */

      L4_MABX_DW.UnitDelay_DSTATE_o[i] =

        L4_MABX_P.UnitDelay_InitialCondition_nl[i];



      /* SystemInitialize for Outport: '<S657>/RawData' */

      L4_MABX_B.Inport[i] = L4_MABX_P.RawData_Y0_e;

    }



    /* SystemInitialize for Outport: '<S657>/RX_time' */

    L4_MABX_B.timeStamp = L4_MABX_P.RX_time_Y0_n;



    /* SystemInitialize for Outport: '<S657>/RX_delta_time' */

    L4_MABX_B.Subtract_j3 = L4_MABX_P.RX_delta_time_Y0_n;



    /* End of SystemInitialize for SubSystem: '<S654>/Decode' */



    /* SystemInitialize for Outport: '<S654>/RX_status' */

    L4_MABX_B.RX_status_bk = L4_MABX_P.RX_status_Y0_e;



    /* End of SystemInitialize for SubSystem: '<S465>/CAN_RX_VI_00' */



    /* SystemInitialize for Enabled SubSystem: '<S636>/SSI2_031' */

    /* SystemInitialize for Outport: '<S637>/PitchAngleExRange' */

    L4_MABX_B.SFunction1_o1_fk = L4_MABX_P.PitchAngleExRange_Y0;



    /* SystemInitialize for Outport: '<S637>/RollAngleExRange' */

    L4_MABX_B.SFunction1_o2_pq = L4_MABX_P.RollAngleExRange_Y0;



    /* SystemInitialize for Outport: '<S637>/PitchAngleExRangeCompensation' */

    L4_MABX_B.SFunction1_o3_eq = L4_MABX_P.PitchAngleExRangeCompensation_Y;



    /* SystemInitialize for Outport: '<S637>/PitchAngleExRangeFigureOfMerit' */

    L4_MABX_B.SFunction1_o4_be = L4_MABX_P.PitchAngleExRangeFigureOfMerit_;



    /* SystemInitialize for Outport: '<S637>/RollAngleExRangeCompensation' */

    L4_MABX_B.SFunction1_o5_fy = L4_MABX_P.RollAngleExRangeCompensation_Y0;



    /* SystemInitialize for Outport: '<S637>/RollAngleExRangeFigureOfMerit' */

    L4_MABX_B.SFunction1_o6_l = L4_MABX_P.RollAngleExRangeFigureOfMerit_Y;



    /* SystemInitialize for Outport: '<S637>/RllAndPtchExRngMsurementLatency' */

    L4_MABX_B.SFunction1_o7_p = L4_MABX_P.RllAndPtchExRngMsurementLatency;



    /* SystemInitialize for Outport: '<S637>/RX status' */

    L4_MABX_B.SFunction1_o8_h = L4_MABX_P.RXstatus_Y0_gi;



    /* SystemInitialize for Outport: '<S637>/RX time' */

    L4_MABX_B.SFunction1_o9_i = L4_MABX_P.RXtime_Y0_ba;



    /* SystemInitialize for Outport: '<S637>/RX delta time' */

    L4_MABX_B.SFunction1_o10_ha = L4_MABX_P.RXdeltatime_Y0_jh;



    /* End of SystemInitialize for SubSystem: '<S636>/SSI2_031' */



    /* SystemInitialize for Enabled SubSystem: '<S627>/PX2_LanePosEst' */

    /* SystemInitialize for Outport: '<S630>/PX2_LanePosEstAngle' */

    L4_MABX_B.SFunction1_o1_oq = L4_MABX_P.PX2_LanePosEstAngle_Y0;



    /* SystemInitialize for Outport: '<S630>/PX2_LanePosEstNumPoints' */

    L4_MABX_B.SFunction1_o2_mr = L4_MABX_P.PX2_LanePosEstNumPoints_Y0;



    /* SystemInitialize for Outport: '<S630>/PX2_LanePosEstPosition' */

    L4_MABX_B.SFunction1_o3_ev = L4_MABX_P.PX2_LanePosEstPosition_Y0;



    /* SystemInitialize for Outport: '<S630>/PX2_LanePosEstNumLanes' */

    L4_MABX_B.SFunction1_o4_aw = L4_MABX_P.PX2_LanePosEstNumLanes_Y0;



    /* SystemInitialize for Outport: '<S630>/RX status' */

    L4_MABX_B.SFunction1_o5_b = L4_MABX_P.RXstatus_Y0_pt;



    /* SystemInitialize for Outport: '<S630>/RX time' */

    L4_MABX_B.SFunction1_o6_kc = L4_MABX_P.RXtime_Y0_pg;



    /* SystemInitialize for Outport: '<S630>/RX delta time' */

    L4_MABX_B.SFunction1_o7_d = L4_MABX_P.RXdeltatime_Y0_huf;



    /* End of SystemInitialize for SubSystem: '<S627>/PX2_LanePosEst' */



    /* SystemInitialize for Enabled SubSystem: '<S634>/Bendix_Prop2C2_Status_30' */

    /* SystemInitialize for Outport: '<S635>/PressureP4' */

    L4_MABX_B.SFunction1_o1_ko = L4_MABX_P.PressureP4_Y0;



    /* SystemInitialize for Outport: '<S635>/PressureP1' */

    L4_MABX_B.SFunction1_o2_jn = L4_MABX_P.PressureP1_Y0;



    /* SystemInitialize for Outport: '<S635>/PressureP21' */

    L4_MABX_B.SFunction1_o3_hm = L4_MABX_P.PressureP21_Y0;



    /* SystemInitialize for Outport: '<S635>/PressureP22' */

    L4_MABX_B.SFunction1_o4_hk = L4_MABX_P.PressureP22_Y0;



    /* SystemInitialize for Outport: '<S635>/PressureP42' */

    L4_MABX_B.SFunction1_o5_fg = L4_MABX_P.PressureP42_Y0;



    /* SystemInitialize for Outport: '<S635>/XPR1ControlStatus' */

    L4_MABX_B.SFunction1_o6_a = L4_MABX_P.XPR1ControlStatus_Y0;



    /* SystemInitialize for Outport: '<S635>/XPR2ControlStatus' */

    L4_MABX_B.SFunction1_o7_a = L4_MABX_P.XPR2ControlStatus_Y0;



    /* SystemInitialize for Outport: '<S635>/XPR3ControlStatus' */

    L4_MABX_B.SFunction1_o8_b = L4_MABX_P.XPR3ControlStatus_Y0;



    /* SystemInitialize for Outport: '<S635>/XPRErrorState' */

    L4_MABX_B.SFunction1_o9_l = L4_MABX_P.XPRErrorState_Y0;



    /* SystemInitialize for Outport: '<S635>/XPRControlMode' */

    L4_MABX_B.SFunction1_o10_d = L4_MABX_P.XPRControlMode_Y0;



    /* SystemInitialize for Outport: '<S635>/RX status' */

    L4_MABX_B.SFunction1_o11_d = L4_MABX_P.RXstatus_Y0_f1;



    /* SystemInitialize for Outport: '<S635>/RX time' */

    L4_MABX_B.SFunction1_o12_k = L4_MABX_P.RXtime_Y0_hc;



    /* SystemInitialize for Outport: '<S635>/RX delta time' */

    L4_MABX_B.SFunction1_o13_g = L4_MABX_P.RXdeltatime_Y0_cy;



    /* End of SystemInitialize for SubSystem: '<S634>/Bendix_Prop2C2_Status_30' */



    /* SystemInitialize for Enabled SubSystem: '<S584>/PropB_REAX_2_13' */

    /* SystemInitialize for Outport: '<S586>/PropB_REAX_2_ActualHandwheelPos' */

    L4_MABX_B.SFunction1_o1_cs = L4_MABX_P.PropB_REAX_2_ActualHandwheelPos;



    /* SystemInitialize for Outport: '<S586>/PropB_REAX_2_EchoedStrWhlPos' */

    L4_MABX_B.SFunction1_o2_jnu = L4_MABX_P.PropB_REAX_2_EchoedStrWhlPos_Y0;



    /* SystemInitialize for Outport: '<S586>/RX status' */

    L4_MABX_B.SFunction1_o3_pv = L4_MABX_P.RXstatus_Y0_g1;



    /* SystemInitialize for Outport: '<S586>/RX time' */

    L4_MABX_B.SFunction1_o4_c = L4_MABX_P.RXtime_Y0_iz;



    /* SystemInitialize for Outport: '<S586>/RX delta time' */

    L4_MABX_B.SFunction1_o5_ni = L4_MABX_P.RXdeltatime_Y0_c;



    /* End of SystemInitialize for SubSystem: '<S584>/PropB_REAX_2_13' */



    /* SystemInitialize for Enabled SubSystem: '<S585>/PropB_REAX_2_13' */

    /* SystemInitialize for Outport: '<S587>/PropB_REAX_2_ActualHandwheelPos' */

    L4_MABX_B.SFunction1_o1_ph = L4_MABX_P.PropB_REAX_2_ActualHandwheelP_c;



    /* SystemInitialize for Outport: '<S587>/PropB_REAX_2_EchoedStrWhlPos' */

    L4_MABX_B.SFunction1_o2_g5 = L4_MABX_P.PropB_REAX_2_EchoedStrWhlPos__c;



    /* SystemInitialize for Outport: '<S587>/RX status' */

    L4_MABX_B.SFunction1_o3_l1 = L4_MABX_P.RXstatus_Y0_il;



    /* SystemInitialize for Outport: '<S587>/RX time' */

    L4_MABX_B.SFunction1_o4_k1 = L4_MABX_P.RXtime_Y0_hu;



    /* SystemInitialize for Outport: '<S587>/RX delta time' */

    L4_MABX_B.SFunction1_o5_j = L4_MABX_P.RXdeltatime_Y0_lw;



    /* End of SystemInitialize for SubSystem: '<S585>/PropB_REAX_2_13' */



    /* SystemInitialize for Atomic SubSystem: '<S65>/Task_10ms' */

    /* InitializeConditions for UnitDelay: '<S97>/Unit Delay1' */

    L4_MABX_DW.UnitDelay1_DSTATE_m = L4_MABX_P.UnitDelay1_InitialCondition;



    /* InitializeConditions for UnitDelay: '<S76>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_fv = L4_MABX_P.Unit_Delay_InitialCondition_jn;



    /* InitializeConditions for UnitDelay: '<S98>/Delay Input1' */

    L4_MABX_DW.DelayInput1_DSTATE_d = L4_MABX_P.DetectFallNonpositive_vinit;



    /* InitializeConditions for UnitDelay: '<S97>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_b1 = L4_MABX_P.UnitDelay_InitialCondition_br;



    /* InitializeConditions for RateTransition: '<S81>/TmpRTBAtSignal Conversion1Inport1' */

    L4_MABX_DW.TmpRTBAtSignalConversion1Inport =

      L4_MABX_P.TmpRTBAtSignalConversion1Inport;



    /* InitializeConditions for UnitDelay: '<S395>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_cx = L4_MABX_P.Unit_Delay_InitialCondition_b1;



    /* InitializeConditions for UnitDelay: '<S396>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_d0 = L4_MABX_P.Unit_Delay_InitialCondition_g;



    /* InitializeConditions for UnitDelay: '<S353>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_e = L4_MABX_P.Unit_Delay_InitialCondition_i;



    /* InitializeConditions for UnitDelay: '<S400>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_aq =

      L4_MABX_P.FixPtUnitDelay2_InitialCondi_f5;



    /* InitializeConditions for UnitDelay: '<S400>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_h =

      L4_MABX_P.FixPtUnitDelay1_InitialCondit_l;



    /* InitializeConditions for UnitDelay: '<S397>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_m = L4_MABX_P.Unit_Delay_InitialCondition_hae;



    /* InitializeConditions for UnitDelay: '<S384>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_iy = L4_MABX_P.Unit_Delay_InitialCondition_aw;



    /* InitializeConditions for UnitDelay: '<S385>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_mv = L4_MABX_P.Unit_Delay_InitialCondition_gt;



    /* InitializeConditions for UnitDelay: '<S351>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_g = L4_MABX_P.Unit_Delay_InitialCondition_fb;



    /* InitializeConditions for UnitDelay: '<S389>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_ip =

      L4_MABX_P.FixPtUnitDelay2_InitialCondi_po;



    /* InitializeConditions for UnitDelay: '<S389>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_hq =

      L4_MABX_P.FixPtUnitDelay1_InitialCondit_d;



    /* InitializeConditions for UnitDelay: '<S386>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_b = L4_MABX_P.Unit_Delay_InitialCondition_c;



    /* InitializeConditions for RateTransition: '<S81>/TmpRTBAtSignal Conversion3Inport1' */

    L4_MABX_DW.TmpRTBAtSignalConversion3Inport =

      L4_MABX_P.TmpRTBAtSignalConversion3Inport;



    /* InitializeConditions for RateTransition: '<S81>/TmpRTBAtSignal Conversion2Inport1' */

    L4_MABX_DW.TmpRTBAtSignalConversion2Inport =

      L4_MABX_P.TmpRTBAtSignalConversion2Inport;



    /* InitializeConditions for UnitDelay: '<S366>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_bw = L4_MABX_P.Unit_Delay_InitialCondition_e;



    /* InitializeConditions for UnitDelay: '<S368>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_ko = L4_MABX_P.Unit_Delay_InitialCondition_ml;



    /* InitializeConditions for UnitDelay: '<S377>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_f =

      L4_MABX_P.FixPtUnitDelay2_InitialCondit_i;



    /* InitializeConditions for UnitDelay: '<S377>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_l =

      L4_MABX_P.FixPtUnitDelay1_InitialCondit_h;



    /* InitializeConditions for UnitDelay: '<S375>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_p = L4_MABX_P.Unit_Delay_InitialCondition_j;



    /* InitializeConditions for UnitDelay: '<S348>/Delay Input1' */

    L4_MABX_DW.DelayInput1_DSTATE[0] = L4_MABX_P.DetectChange1_vinit;



    /* InitializeConditions for UnitDelay: '<S355>/Delay Input1' */

    L4_MABX_DW.DelayInput1_DSTATE_f[0] = L4_MABX_P.DetectChange1_vinit_n;



    /* InitializeConditions for UnitDelay: '<S348>/Delay Input1' */

    L4_MABX_DW.DelayInput1_DSTATE[1] = L4_MABX_P.DetectChange1_vinit;



    /* InitializeConditions for UnitDelay: '<S355>/Delay Input1' */

    L4_MABX_DW.DelayInput1_DSTATE_f[1] = L4_MABX_P.DetectChange1_vinit_n;



    /* InitializeConditions for UnitDelay: '<S357>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_l = L4_MABX_P.Unit_Delay_InitialCondition_ag;



    /* InitializeConditions for UnitDelay: '<S361>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_c =

      L4_MABX_P.FixPtUnitDelay2_InitialCondi_ck;



    /* InitializeConditions for UnitDelay: '<S361>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_ej =

      L4_MABX_P.FixPtUnitDelay1_InitialCondit_m;



    /* InitializeConditions for UnitDelay: '<S356>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_1_DSTATE_j = L4_MABX_P.Unit_Delay_1_InitialCondition;

    L4_MABX_DW.Unit_Delay_2_DSTATE_e = L4_MABX_P.Unit_Delay_2_InitialCondition;

    L4_MABX_DW.Unit_Delay_3_DSTATE_j = L4_MABX_P.Unit_Delay_3_InitialCondition;



    /* InitializeConditions for UnitDelay: '<S354>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_f = L4_MABX_P.Unit_Delay_InitialCondition_e2;



    /* InitializeConditions for UnitDelay: '<S107>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_eu4 = L4_MABX_P.Unit_Delay_InitialCondition_ip;



    /* InitializeConditions for UnitDelay: '<S203>/Unit_Delay1' */

    L4_MABX_DW.Unit_Delay1_DSTATE_di = L4_MABX_P.Unit_Delay1_InitialCondition_f;



    /* InitializeConditions for UnitDelay: '<S203>/Unit_Delay2' */

    L4_MABX_DW.Unit_Delay2_DSTATE_e = L4_MABX_P.Unit_Delay2_InitialCondition_a;



    /* InitializeConditions for UnitDelay: '<S202>/UD' */

    L4_MABX_DW.UD_DSTATE = L4_MABX_P.DiscreteDerivative1_ICPrevScale;



    /* InitializeConditions for UnitDelay: '<S333>/Unit_Delay1' */

    L4_MABX_DW.Unit_Delay1_DSTATE_db = L4_MABX_P.Unit_Delay1_InitialCondition_m;



    /* InitializeConditions for UnitDelay: '<S333>/Unit_Delay2' */

    L4_MABX_DW.Unit_Delay2_DSTATE_d = L4_MABX_P.Unit_Delay2_InitialCondition_g;



    /* InitializeConditions for UnitDelay: '<S332>/Delay Input1' */

    L4_MABX_DW.DelayInput1_DSTATE_f0 = L4_MABX_P.DetectChange_vinit;



    /* InitializeConditions for UnitDelay: '<S334>/Unit_Delay1' */

    L4_MABX_DW.Unit_Delay1_DSTATE_a = L4_MABX_P.Unit_Delay1_InitialCondition_ps;



    /* InitializeConditions for UnitDelay: '<S334>/Unit_Delay2' */

    L4_MABX_DW.Unit_Delay2_DSTATE_i = L4_MABX_P.Unit_Delay2_InitialCondition_ji;



    /* InitializeConditions for UnitDelay: '<S335>/Unit_Delay1' */

    L4_MABX_DW.Unit_Delay1_DSTATE_p3 = L4_MABX_P.Unit_Delay1_InitialCondition_j;



    /* InitializeConditions for UnitDelay: '<S335>/Unit_Delay2' */

    L4_MABX_DW.Unit_Delay2_DSTATE_p = L4_MABX_P.Unit_Delay2_InitialCondition_ap;



    /* InitializeConditions for UnitDelay: '<S285>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_d = L4_MABX_P.UnitDelay_InitialCondition_c;



    /* InitializeConditions for UnitDelay: '<S295>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_m = L4_MABX_P.UnitDelay_InitialCondition;



    /* InitializeConditions for UnitDelay: '<S296>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_m0 = L4_MABX_P.UnitDelay_InitialCondition_g;



    /* InitializeConditions for UnitDelay: '<S296>/Unit Delay1' */

    L4_MABX_DW.UnitDelay1_DSTATE_k = L4_MABX_P.UnitDelay1_InitialCondition_j;



    /* InitializeConditions for RateTransition: '<S80>/TmpRTBAtrad2deg1Inport1' */

    L4_MABX_DW.TmpRTBAtrad2deg1Inport1_Buffer0 =

      L4_MABX_P.TmpRTBAtrad2deg1Inport1_Initial;



    /* InitializeConditions for RateTransition: '<S80>/TmpRTBAtsignCurveOffsetInport1' */

    L4_MABX_DW.TmpRTBAtsignCurveOffsetInport1_ =

      L4_MABX_P.TmpRTBAtsignCurveOffsetInport1_;



    /* InitializeConditions for UnitDelay: '<S290>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_m1 = L4_MABX_P.UnitDelay_InitialCondition_eo;



    /* InitializeConditions for RateTransition: '<S284>/TmpRTBAtAdd2Inport2' */

    L4_MABX_DW.TmpRTBAtAdd2Inport2_Buffer0 =

      L4_MABX_P.TmpRTBAtAdd2Inport2_InitialCond;



    /* InitializeConditions for UnitDelay: '<S314>/Delay Input2' */

    L4_MABX_DW.DelayInput2_DSTATE = L4_MABX_P.DelayInput2_InitialCondition;



    /* InitializeConditions for DiscreteIntegrator: '<S313>/Integrator' */

    L4_MABX_DW.Integrator_DSTATE = L4_MABX_P.Integrator_IC;

    L4_MABX_DW.Integrator_PrevResetState = 2;



    /* InitializeConditions for DiscreteIntegrator: '<S313>/Filter' */

    L4_MABX_DW.Filter_DSTATE = L4_MABX_P.Filter_IC;

    L4_MABX_DW.Filter_PrevResetState = 2;



    /* InitializeConditions for UnitDelay: '<S317>/Delay Input' */

    L4_MABX_DW.DelayInput_DSTATE = L4_MABX_P.TransferFcnLeadorLag_ICPrevInpu;



    /* InitializeConditions for UnitDelay: '<S317>/Delay Output' */

    L4_MABX_DW.DelayOutput_DSTATE = L4_MABX_P.TransferFcnLeadorLag_ICPrevOutp;



    /* InitializeConditions for UnitDelay: '<S315>/Delay Input2' */

    L4_MABX_DW.DelayInput2_DSTATE_a = L4_MABX_P.DelayInput2_InitialCondition_m;



    /* InitializeConditions for DiscreteIntegrator: '<S307>/Discrete-Time Integrator' */

    L4_MABX_DW.DiscreteTimeIntegrator_IC_LOADI = 1U;

    L4_MABX_DW.DiscreteTimeIntegrator_PrevRese = 2;



    /* InitializeConditions for UnitDelay: '<S327>/Delay Input2' */

    L4_MABX_DW.DelayInput2_DSTATE_l = L4_MABX_P.DelayInput2_InitialCondition_g;



    /* InitializeConditions for UnitDelay: '<S304>/Delay Input2' */

    L4_MABX_DW.DelayInput2_DSTATE_o = L4_MABX_P.DelayInput2_InitialCondition_b;



    /* InitializeConditions for DiscreteIntegrator: '<S80>/Discrete-Time Integrator' */

    L4_MABX_DW.DiscreteTimeIntegrator_DSTATE_e =

      L4_MABX_P.DiscreteTimeIntegrator_IC;

    L4_MABX_DW.DiscreteTimeIntegrator_PrevRe_e = 0;



    /* InitializeConditions for RateLimiter: '<S301>/Limit Rate Limiter' */

    L4_MABX_DW.PrevY = L4_MABX_P.LimitRateLimiter_IC;



    /* InitializeConditions for RateLimiter: '<S316>/Limit Rate Limiter' */

    L4_MABX_DW.PrevY_o = L4_MABX_P.LimitRateLimiter_IC_i;



    /* InitializeConditions for UnitDelay: '<S80>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_e = L4_MABX_P.UnitDelay_InitialCondition_g1;



    /* InitializeConditions for UnitDelay: '<S379>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_aw =

      L4_MABX_P.FixPtUnitDelay2_InitialCondit_g;



    /* InitializeConditions for UnitDelay: '<S379>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_p =

      L4_MABX_P.FixPtUnitDelay1_InitialCondi_dl;



    /* InitializeConditions for UnitDelay: '<S380>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_gx =

      L4_MABX_P.FixPtUnitDelay2_InitialCondi_pz;



    /* InitializeConditions for UnitDelay: '<S380>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_g0 =

      L4_MABX_P.FixPtUnitDelay1_InitialCondi_ol;



    /* InitializeConditions for UnitDelay: '<S374>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_j = L4_MABX_P.Unit_Delay_InitialCondition_b;



    /* SystemInitialize for Enabled SubSystem: '<S79>/Throttle_controller_gov' */

    /* InitializeConditions for UnitDelay: '<S220>/Unit_Delay1' */

    L4_MABX_DW.Unit_Delay1_DSTATE_p1 = L4_MABX_P.Unit_Delay1_InitialCondition_o;



    /* InitializeConditions for UnitDelay: '<S220>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_lq = L4_MABX_P.Unit_Delay_InitialCondition_b2;



    /* InitializeConditions for UnitDelay: '<S247>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_be = L4_MABX_P.Unit_Delay_InitialCondition_lj;



    /* InitializeConditions for UnitDelay: '<S267>/Unit_Delay1' */

    L4_MABX_DW.Unit_Delay1_DSTATE_h = L4_MABX_P.Unit_Delay1_InitialCondition_a;



    /* InitializeConditions for UnitDelay: '<S268>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_fi = L4_MABX_P.Unit_Delay_InitialCondition_bm;



    /* InitializeConditions for UnitDelay: '<S272>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_gq =

      L4_MABX_P.FixPtUnitDelay2_InitialCondit_a;



    /* InitializeConditions for UnitDelay: '<S272>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_a =

      L4_MABX_P.FixPtUnitDelay1_InitialCondit_o;



    /* InitializeConditions for UnitDelay: '<S267>/Unit_Delay2' */

    L4_MABX_DW.Unit_Delay2_DSTATE_m = L4_MABX_P.Unit_Delay2_InitialCondition_j;



    /* InitializeConditions for UnitDelay: '<S222>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_fz = L4_MABX_P.Unit_Delay_InitialCondition_kg;



    /* SystemInitialize for Enabled SubSystem: '<S244>/Calculate_D_term' */

    L4_MA_Calculate_D_term_Init(&L4_MABX_B.Calculate_D_term_h,

      &L4_MABX_DW.Calculate_D_term_h, &L4_MABX_P.Calculate_D_term_h);



    /* End of SystemInitialize for SubSystem: '<S244>/Calculate_D_term' */



    /* SystemInitialize for Enabled SubSystem: '<S244>/Calculate_I_term' */

    L4_MA_Calculate_I_term_Init(&L4_MABX_B.Calculate_I_term_n,

      &L4_MABX_DW.Calculate_I_term_n, &L4_MABX_P.Calculate_I_term_n);



    /* End of SystemInitialize for SubSystem: '<S244>/Calculate_I_term' */



    /* SystemInitialize for Outport: '<S212>/PID_output' */

    L4_MABX_B.If_Then_Else_pi.Switch = L4_MABX_P.PID_output_Y0_c;



    /* SystemInitialize for Outport: '<S212>/PID_output_unlim' */

    L4_MABX_B.Add_ds = L4_MABX_P.PID_output_unlim_Y0;



    /* SystemInitialize for Outport: '<S212>/PID_control_error' */

    L4_MABX_B.If_Then_Else_k2.Switch = L4_MABX_P.PID_control_error_Y0;



    /* SystemInitialize for Outport: '<S212>/PID_p_term' */

    L4_MABX_B.Product_i = L4_MABX_P.PID_p_term_Y0;



    /* SystemInitialize for Outport: '<S212>/PID_i_term' */

    L4_MABX_B.PID_i_term_c = L4_MABX_P.PID_i_term_Y0;



    /* SystemInitialize for Outport: '<S212>/PID_d_term' */

    L4_MABX_B.PID_d_term_c = L4_MABX_P.PID_d_term_Y0;



    /* SystemInitialize for Outport: '<S212>/PID_hold_i_term_f' */

    L4_MABX_B.PID_hold_i_term_f_b = L4_MABX_P.PID_hold_i_term_f_Y0;



    /* End of SystemInitialize for SubSystem: '<S79>/Throttle_controller_gov' */



    /* SystemInitialize for Enabled SubSystem: '<S105>/Determine_shift_interlock_brake_pressure_target' */

    /* InitializeConditions for UnitDelay: '<S184>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_o = L4_MABX_P.Unit_Delay_InitialCondition_l;



    /* InitializeConditions for UnitDelay: '<S194>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_ae = L4_MABX_P.Unit_Delay_InitialCondition_cl;



    /* InitializeConditions for UnitDelay: '<S198>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_l =

      L4_MABX_P.FixPtUnitDelay2_InitialCondit_f;



    /* InitializeConditions for UnitDelay: '<S198>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_ds =

      L4_MABX_P.FixPtUnitDelay1_InitialCondit_j;



    /* InitializeConditions for UnitDelay: '<S195>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_om = L4_MABX_P.Unit_Delay_InitialCondition_ha;



    /* SystemInitialize for Outport: '<S184>/Shift_interlock_brake_press_target_kpa' */

    L4_MABX_B.If_Then_Else_il.Switch = L4_MABX_P.Shift_interlock_brake_press_tar;



    /* SystemInitialize for Outport: '<S184>/F_Shift_interlock_conditions_met' */

    L4_MABX_B.F_Shift_interlock_conditions_me =

      L4_MABX_P.F_Shift_interlock_conditions_me;



    /* End of SystemInitialize for SubSystem: '<S105>/Determine_shift_interlock_brake_pressure_target' */



    /* SystemInitialize for Enabled SubSystem: '<S105>/Determine_brake_hold_pressure_target' */

    /* InitializeConditions for UnitDelay: '<S183>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_c = L4_MABX_P.Unit_Delay_InitialCondition_d;



    /* InitializeConditions for UnitDelay: '<S187>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_or = L4_MABX_P.Unit_Delay_InitialCondition_fy;



    /* InitializeConditions for UnitDelay: '<S191>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_je =

      L4_MABX_P.FixPtUnitDelay2_InitialCondit_e;



    /* InitializeConditions for UnitDelay: '<S191>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_b =

      L4_MABX_P.FixPtUnitDelay1_InitialCondit_p;



    /* InitializeConditions for UnitDelay: '<S188>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_oj = L4_MABX_P.Unit_Delay_InitialCondition_k;



    /* SystemInitialize for Outport: '<S183>/Brake_hold_brake_press_target_kpa' */

    L4_MABX_B.If_Then_Else_gj.Switch = L4_MABX_P.Brake_hold_brake_press_target_k;



    /* SystemInitialize for Outport: '<S183>/F_Brake_hold_conditions_met' */

    L4_MABX_B.F_Brake_hold_conditions_met =

      L4_MABX_P.F_Brake_hold_conditions_met_Y0;



    /* End of SystemInitialize for SubSystem: '<S105>/Determine_brake_hold_pressure_target' */



    /* SystemInitialize for Enabled SubSystem: '<S77>/Bendix_2C2_brake_application_pressure_feedback_controller' */

    /* InitializeConditions for UnitDelay: '<S111>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_dc = L4_MABX_P.Unit_Delay_InitialCondition;



    /* InitializeConditions for UnitDelay: '<S115>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_omj = L4_MABX_P.Unit_Delay_InitialCondition_lt;



    /* InitializeConditions for UnitDelay: '<S135>/Unit_Delay1' */

    L4_MABX_DW.Unit_Delay1_DSTATE_b = L4_MABX_P.Unit_Delay1_InitialCondition;



    /* InitializeConditions for UnitDelay: '<S136>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_h4 = L4_MABX_P.Unit_Delay_InitialCondition_og;



    /* InitializeConditions for UnitDelay: '<S140>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_gm =

      L4_MABX_P.FixPtUnitDelay2_InitialConditio;



    /* InitializeConditions for UnitDelay: '<S140>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_g1 =

      L4_MABX_P.FixPtUnitDelay1_InitialConditio;



    /* InitializeConditions for UnitDelay: '<S135>/Unit_Delay2' */

    L4_MABX_DW.Unit_Delay2_DSTATE_dy = L4_MABX_P.Unit_Delay2_InitialCondition;



    /* InitializeConditions for UnitDelay: '<S110>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_i2 = L4_MABX_P.Unit_Delay_InitialCondition_p;



    /* SystemInitialize for Enabled SubSystem: '<S112>/Calculate_D_term' */

    L4_MA_Calculate_D_term_Init(&L4_MABX_B.Calculate_D_term,

      &L4_MABX_DW.Calculate_D_term, &L4_MABX_P.Calculate_D_term);



    /* End of SystemInitialize for SubSystem: '<S112>/Calculate_D_term' */



    /* SystemInitialize for Enabled SubSystem: '<S112>/Calculate_I_term' */

    L4_MA_Calculate_I_term_Init(&L4_MABX_B.Calculate_I_term,

      &L4_MABX_DW.Calculate_I_term, &L4_MABX_P.Calculate_I_term);



    /* End of SystemInitialize for SubSystem: '<S112>/Calculate_I_term' */



    /* SystemInitialize for Outport: '<S102>/PID_output' */

    L4_MABX_B.If_Then_Else_nj.Switch = L4_MABX_P.PID_output_Y0;



    /* End of SystemInitialize for SubSystem: '<S77>/Bendix_2C2_brake_application_pressure_feedback_controller' */



    /* SystemInitialize for Chart: '<S350>/VehicleSpeedSetpointDynamicCalculation' */

    L4_MABX_B.TimeVectorRaw[0] = 0.0;

    L4_MABX_B.TimeVectorRaw[1] = 0.001;

    L4_MABX_B.TimeVectorRaw[2] = 0.002;

    L4_MABX_B.TimeVectorRaw[3] = 0.003;

    L4_MABX_B.TimeVectorRaw[4] = 0.004;

    L4_MABX_B.TimeVectorRaw[5] = 0.005;

    L4_MABX_B.PositionVectorRaw[0] = 0.0;

    L4_MABX_B.PositionVectorRaw[1] = 0.001;

    L4_MABX_B.PositionVectorRaw[2] = 0.002;

    L4_MABX_B.PositionVectorRaw[3] = 0.003;

    L4_MABX_B.PositionVectorRaw[4] = 0.004;

    L4_MABX_B.PositionVectorRaw[5] = 0.005;

    for (i = 0; i < 6; i++) {

      L4_MABX_B.VelocityVectorRaw[i] = 0.0;

      L4_MABX_B.AccelerationVectorRaw[i] = 0.0;

      L4_MABX_B.JerkVectorRaw[i] = 0.0;

    }



    /* End of SystemInitialize for Chart: '<S350>/VehicleSpeedSetpointDynamicCalculation' */



    /* SystemInitialize for Chart: '<S350>/TwentyPointVectorCalculation' */

    L4_MABX_B.TimeVector[0] = 0.0;

    L4_MABX_B.TimeVector[1] = 0.001;

    L4_MABX_B.TimeVector[2] = 0.002;

    L4_MABX_B.TimeVector[3] = 0.003;

    L4_MABX_B.TimeVector[4] = 0.004;

    L4_MABX_B.TimeVector[5] = 0.005;

    L4_MABX_B.TimeVector[6] = 0.006;

    L4_MABX_B.TimeVector[7] = 0.007;

    L4_MABX_B.TimeVector[8] = 0.008;

    L4_MABX_B.TimeVector[9] = 0.0090000000000000011;

    L4_MABX_B.TimeVector[10] = 0.01;

    L4_MABX_B.TimeVector[11] = 0.011;

    L4_MABX_B.TimeVector[12] = 0.012;

    L4_MABX_B.TimeVector[13] = 0.013000000000000001;

    L4_MABX_B.TimeVector[14] = 0.014;

    L4_MABX_B.TimeVector[15] = 0.015;

    L4_MABX_B.TimeVector[16] = 0.016;

    L4_MABX_B.TimeVector[17] = 0.017;

    L4_MABX_B.TimeVector[18] = 0.018000000000000002;

    L4_MABX_B.TimeVector[19] = 0.019;

    L4_MABX_B.TimeVector[20] = 0.02;

    L4_MABX_B.TimeVector[21] = 0.021;

    L4_MABX_B.TimeVector[22] = 0.022;

    L4_MABX_B.TimeVector[23] = 0.023;

    L4_MABX_B.TimeVector[24] = 0.024;

    L4_MABX_B.TimeVector[25] = 0.025;

    L4_MABX_B.TimeVector[26] = 0.026000000000000002;

    L4_MABX_B.TimeVector[27] = 0.027;

    L4_MABX_B.TimeVector[28] = 0.028;

    L4_MABX_B.TimeVector[29] = 0.029;

    L4_MABX_B.TimeVector[30] = 0.03;

    L4_MABX_B.TimeVector[31] = 0.031;

    L4_MABX_B.TimeVector[32] = 0.032;

    L4_MABX_B.PositionVector[0] = 0.0;

    L4_MABX_B.PositionVector[1] = 0.001;

    L4_MABX_B.PositionVector[2] = 0.002;

    L4_MABX_B.PositionVector[3] = 0.003;

    L4_MABX_B.PositionVector[4] = 0.004;

    L4_MABX_B.PositionVector[5] = 0.005;

    L4_MABX_B.PositionVector[6] = 0.006;

    L4_MABX_B.PositionVector[7] = 0.007;

    L4_MABX_B.PositionVector[8] = 0.008;

    L4_MABX_B.PositionVector[9] = 0.0090000000000000011;

    L4_MABX_B.PositionVector[10] = 0.01;

    L4_MABX_B.PositionVector[11] = 0.011;

    L4_MABX_B.PositionVector[12] = 0.012;

    L4_MABX_B.PositionVector[13] = 0.013000000000000001;

    L4_MABX_B.PositionVector[14] = 0.014;

    L4_MABX_B.PositionVector[15] = 0.015;

    L4_MABX_B.PositionVector[16] = 0.016;

    L4_MABX_B.PositionVector[17] = 0.017;

    L4_MABX_B.PositionVector[18] = 0.018000000000000002;

    L4_MABX_B.PositionVector[19] = 0.019;

    L4_MABX_B.PositionVector[20] = 0.02;

    L4_MABX_B.PositionVector[21] = 0.021;

    L4_MABX_B.PositionVector[22] = 0.022;

    L4_MABX_B.PositionVector[23] = 0.023;

    L4_MABX_B.PositionVector[24] = 0.024;

    L4_MABX_B.PositionVector[25] = 0.025;

    L4_MABX_B.PositionVector[26] = 0.026000000000000002;

    L4_MABX_B.PositionVector[27] = 0.027;

    L4_MABX_B.PositionVector[28] = 0.028;

    L4_MABX_B.PositionVector[29] = 0.029;

    L4_MABX_B.PositionVector[30] = 0.03;

    L4_MABX_B.PositionVector[31] = 0.031;

    L4_MABX_B.PositionVector[32] = 0.032;

    memset(&L4_MABX_B.VelocityVector[0], 0, 33U * sizeof(real_T));

    memset(&L4_MABX_B.AccelerationVector[0], 0, 33U * sizeof(real_T));

    memset(&L4_MABX_B.JerkVector[0], 0, 33U * sizeof(real_T));



    /* SystemInitialize for Enabled SubSystem: '<S77>/Bendix_2C2_vehicle_speed_feedback_pressure_controller' */

    /* InitializeConditions for UnitDelay: '<S146>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_eu = L4_MABX_P.Unit_Delay_InitialCondition_f;



    /* InitializeConditions for UnitDelay: '<S153>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_n = L4_MABX_P.Unit_Delay_InitialCondition_jb;



    /* InitializeConditions for UnitDelay: '<S173>/Unit_Delay1' */

    L4_MABX_DW.Unit_Delay1_DSTATE_f = L4_MABX_P.Unit_Delay1_InitialCondition_p;



    /* InitializeConditions for UnitDelay: '<S174>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_g4 = L4_MABX_P.Unit_Delay_InitialCondition_lq;



    /* InitializeConditions for UnitDelay: '<S178>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_o =

      L4_MABX_P.FixPtUnitDelay2_InitialCondit_p;



    /* InitializeConditions for UnitDelay: '<S178>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_g2 =

      L4_MABX_P.FixPtUnitDelay1_InitialCondit_b;



    /* InitializeConditions for UnitDelay: '<S173>/Unit_Delay2' */

    L4_MABX_DW.Unit_Delay2_DSTATE_c = L4_MABX_P.Unit_Delay2_InitialCondition_b;



    /* InitializeConditions for UnitDelay: '<S145>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_h = L4_MABX_P.Unit_Delay_InitialCondition_h;



    /* SystemInitialize for Enabled SubSystem: '<S150>/Calculate_D_term' */

    L4_MA_Calculate_D_term_Init(&L4_MABX_B.Calculate_D_term_p,

      &L4_MABX_DW.Calculate_D_term_p, &L4_MABX_P.Calculate_D_term_p);



    /* End of SystemInitialize for SubSystem: '<S150>/Calculate_D_term' */



    /* SystemInitialize for Enabled SubSystem: '<S150>/Calculate_I_term' */

    L4_MA_Calculate_I_term_Init(&L4_MABX_B.Calculate_I_term_e,

      &L4_MABX_DW.Calculate_I_term_e, &L4_MABX_P.Calculate_I_term_e);



    /* End of SystemInitialize for SubSystem: '<S150>/Calculate_I_term' */



    /* SystemInitialize for Outport: '<S103>/PID_output' */

    L4_MABX_B.If_Then_Else_fo.Switch = L4_MABX_P.PID_output_Y0_p;



    /* End of SystemInitialize for SubSystem: '<S77>/Bendix_2C2_vehicle_speed_feedback_pressure_controller' */



    /* SystemInitialize for Chart: '<S79>/Chart' */

    L4_MABX_DW.is_active_c19_SUB_L4_Task_10ms_ = 0U;

    L4_MABX_DW.is_c19_SUB_L4_Task_10ms_SUB_STA = L4_MABX_IN_NO_ACTIVE_CHILD;

    L4_MABX_B.CtrlState = ENUM_AUTO_CTRL_STATE_T_NOT_AVAILABLE;

    L4_MABX_B.VehCtrlState = ENUM_AUTO_CTRL_VEHICLE_STATE_T_NOT_AVAILABLE;



    /* SystemInitialize for Enabled SubSystem: '<S79>/Engine_speed_target' */

    /* SystemInitialize for Outport: '<S210>/Out1' */

    L4_MABX_B.MinMax1_n = L4_MABX_P.Out1_Y0;



    /* End of SystemInitialize for SubSystem: '<S79>/Engine_speed_target' */



    /* SystemInitialize for Chart: '<S211>/Relay_control_state_machine' */

    L4_MABX_DW.is_POWER_DOWN_ROUTINE = L4_MABX_IN_NO_ACTIVE_CHILD;

    L4_MABX_DW.is_POWER_UP_ROUTINE = L4_MABX_IN_NO_ACTIVE_CHILD;

    L4_MABX_DW.temporalCounter_i1 = 0U;

    L4_MABX_DW.is_active_c6_SUB_L4_Task_10ms_S = 0U;

    L4_MABX_DW.is_c6_SUB_L4_Task_10ms_SUB_STAT = L4_MABX_IN_NO_ACTIVE_CHILD;



    /* SystemInitialize for Chart: '<S283>/Chart' */

    L4_MABX_DW.is_active_c12_SUB_L4_Task_10ms_ = 0U;

    L4_MABX_DW.is_c12_SUB_L4_Task_10ms_SUB_STE = L4_MABX_IN_NO_ACTIVE_CHILD;



    /* SystemInitialize for Enabled SubSystem: '<S283>/Slew_at_event' */

    /* InitializeConditions for UnitDelay: '<S342>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_bd = L4_MABX_P.Unit_Delay_InitialCondition_ls;



    /* InitializeConditions for UnitDelay: '<S343>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_jt = L4_MABX_P.Unit_Delay_InitialCondition_i0;



    /* InitializeConditions for UnitDelay: '<S346>/FixPt Unit Delay2' */

    L4_MABX_DW.FixPtUnitDelay2_DSTATE_j =

      L4_MABX_P.FixPtUnitDelay2_InitialCondit_c;



    /* InitializeConditions for UnitDelay: '<S346>/FixPt Unit Delay1' */

    L4_MABX_DW.FixPtUnitDelay1_DSTATE_ov =

      L4_MABX_P.FixPtUnitDelay1_InitialCondit_f;



    /* InitializeConditions for UnitDelay: '<S341>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_ll = L4_MABX_P.Unit_Delay_InitialCondition_ld;



    /* SystemInitialize for Outport: '<S340>/F_Out_slewing' */

    L4_MABX_B.LogicalOperator_dm = L4_MABX_P.F_Out_slewing_Y0;



    /* SystemInitialize for Outport: '<S340>/Out' */

    L4_MABX_B.If_Then_Else_n3.Switch = L4_MABX_P.Out_Y0;



    /* End of SystemInitialize for SubSystem: '<S283>/Slew_at_event' */

    /* End of SystemInitialize for SubSystem: '<S65>/Task_10ms' */



    /* SystemInitialize for Enabled SubSystem: '<S631>/PosRapidUpdate_011' */

    /* SystemInitialize for Outport: '<S632>/Latitude_' */

    L4_MABX_B.SFunction1_o1_bh = L4_MABX_P.Latitude_Y0;



    /* SystemInitialize for Outport: '<S632>/Longitude_' */

    L4_MABX_B.SFunction1_o2_db = L4_MABX_P.Longitude_Y0;



    /* SystemInitialize for Outport: '<S632>/RX status' */

    L4_MABX_B.SFunction1_o3_bt = L4_MABX_P.RXstatus_Y0_db;



    /* SystemInitialize for Outport: '<S632>/RX time' */

    L4_MABX_B.SFunction1_o4_ez = L4_MABX_P.RXtime_Y0_b;



    /* SystemInitialize for Outport: '<S632>/RX delta time' */

    L4_MABX_B.SFunction1_o5_gx = L4_MABX_P.RXdeltatime_Y0_h2;



    /* End of SystemInitialize for SubSystem: '<S631>/PosRapidUpdate_011' */



    /* SystemInitialize for Enabled SubSystem: '<S631>/PosRapidUpdate_1' */

    /* SystemInitialize for Outport: '<S633>/Latitude_' */

    L4_MABX_B.SFunction1_o1_ju = L4_MABX_P.Latitude_Y0_e;



    /* SystemInitialize for Outport: '<S633>/Longitude_' */

    L4_MABX_B.SFunction1_o2_aq = L4_MABX_P.Longitude_Y0_f;



    /* SystemInitialize for Outport: '<S633>/RX status' */

    L4_MABX_B.SFunction1_o3_a = L4_MABX_P.RXstatus_Y0_m5;



    /* SystemInitialize for Outport: '<S633>/RX time' */

    L4_MABX_B.SFunction1_o4_ex = L4_MABX_P.RXtime_Y0_c4;



    /* SystemInitialize for Outport: '<S633>/RX delta time' */

    L4_MABX_B.SFunction1_o5_nb = L4_MABX_P.RXdeltatime_Y0_fd;



    /* End of SystemInitialize for SubSystem: '<S631>/PosRapidUpdate_1' */



    /* SystemInitialize for Enabled SubSystem: '<S511>/CCVS1_00' */

    /* SystemInitialize for Outport: '<S512>/TwoSpeedAxleSwitch' */

    L4_MABX_B.SFunction1_o1_g3 = L4_MABX_P.TwoSpeedAxleSwitch_Y0;



    /* SystemInitialize for Outport: '<S512>/ParkingBrakeSwitch' */

    L4_MABX_B.SFunction1_o2_g4 = L4_MABX_P.ParkingBrakeSwitch_Y0;



    /* SystemInitialize for Outport: '<S512>/CruiseCtrlPauseSwitch' */

    L4_MABX_B.SFunction1_o3_ne = L4_MABX_P.CruiseCtrlPauseSwitch_Y0;



    /* SystemInitialize for Outport: '<S512>/ParkBrakeReleaseInhibitRq' */

    L4_MABX_B.SFunction1_o4_e3 = L4_MABX_P.ParkBrakeReleaseInhibitRq_Y0;



    /* SystemInitialize for Outport: '<S512>/WheelBasedVehicleSpeed' */

    WheelBasedVehicleSpeed = L4_MABX_P.WheelBasedVehicleSpeed_Y0;



    /* SystemInitialize for Outport: '<S512>/CruiseCtrlActive' */

    L4_MABX_B.SFunction1_o6_oc = L4_MABX_P.CruiseCtrlActive_Y0;



    /* SystemInitialize for Outport: '<S512>/CruiseCtrlEnableSwitch' */

    L4_MABX_B.SFunction1_o7_dk = L4_MABX_P.CruiseCtrlEnableSwitch_Y0;



    /* SystemInitialize for Outport: '<S512>/BrakeSwitch' */

    BrakeSwitch = L4_MABX_P.BrakeSwitch_Y0;



    /* SystemInitialize for Outport: '<S512>/ClutchSwitch' */

    L4_MABX_B.SFunction1_o9_p = L4_MABX_P.ClutchSwitch_Y0;



    /* SystemInitialize for Outport: '<S512>/CruiseCtrlSetSwitch' */

    L4_MABX_B.SFunction1_o10_or = L4_MABX_P.CruiseCtrlSetSwitch_Y0;



    /* SystemInitialize for Outport: '<S512>/CruiseCtrlCoastSwitch' */

    L4_MABX_B.SFunction1_o11_ae = L4_MABX_P.CruiseCtrlCoastSwitch_Y0;



    /* SystemInitialize for Outport: '<S512>/CruiseCtrlResumeSwitch' */

    L4_MABX_B.SFunction1_o12_jy = L4_MABX_P.CruiseCtrlResumeSwitch_Y0;



    /* SystemInitialize for Outport: '<S512>/CruiseCtrlAccelerateSwitch' */

    L4_MABX_B.SFunction1_o13_ou = L4_MABX_P.CruiseCtrlAccelerateSwitch_Y0;



    /* SystemInitialize for Outport: '<S512>/CruiseCtrlSetSpeed' */

    L4_MABX_B.SFunction1_o14_b = L4_MABX_P.CruiseCtrlSetSpeed_Y0;



    /* SystemInitialize for Outport: '<S512>/PTOGovernorState' */

    L4_MABX_B.SFunction1_o15_dd = L4_MABX_P.PTOGovernorState_Y0;



    /* SystemInitialize for Outport: '<S512>/CruiseCtrlStates' */

    L4_MABX_B.SFunction1_o16_g = L4_MABX_P.CruiseCtrlStates_Y0;



    /* SystemInitialize for Outport: '<S512>/EngIdleIncrementSwitch' */

    L4_MABX_B.SFunction1_o17_n = L4_MABX_P.EngIdleIncrementSwitch_Y0;



    /* SystemInitialize for Outport: '<S512>/EngIdleDecrementSwitch' */

    L4_MABX_B.SFunction1_o18_g = L4_MABX_P.EngIdleDecrementSwitch_Y0;



    /* SystemInitialize for Outport: '<S512>/EngTestModeSwitch' */

    L4_MABX_B.SFunction1_o19_a = L4_MABX_P.EngTestModeSwitch_Y0;



    /* SystemInitialize for Outport: '<S512>/EngShutdownOverrideSwitch' */

    L4_MABX_B.SFunction1_o20_ir = L4_MABX_P.EngShutdownOverrideSwitch_Y0;



    /* SystemInitialize for Outport: '<S512>/RX status' */

    L4_MABX_B.SFunction1_o21_j = L4_MABX_P.RXstatus_Y0_p;



    /* SystemInitialize for Outport: '<S512>/RX time' */

    L4_MABX_B.SFunction1_o22_oy = L4_MABX_P.RXtime_Y0_a;



    /* SystemInitialize for Outport: '<S512>/RX delta time' */

    L4_MABX_B.SFunction1_o23_o = L4_MABX_P.RXdeltatime_Y0_j;



    /* End of SystemInitialize for SubSystem: '<S511>/CCVS1_00' */



    /* SystemInitialize for Enabled SubSystem: '<S515>/COGSOGRapidUpdate_00' */

    /* SystemInitialize for Outport: '<S516>/SID' */

    L4_MABX_B.SFunction1_o1_nq = L4_MABX_P.SID_Y0;



    /* SystemInitialize for Outport: '<S516>/COGReference' */

    L4_MABX_B.SFunction1_o2_co = L4_MABX_P.COGReference_Y0;



    /* SystemInitialize for Outport: '<S516>/CourseOverGround' */

    L4_MABX_B.SFunction1_o3_at = L4_MABX_P.CourseOverGround_Y0;



    /* SystemInitialize for Outport: '<S516>/SpeedOverGround' */

    L4_MABX_B.SFunction1_o4_az = L4_MABX_P.SpeedOverGround_Y0;



    /* SystemInitialize for Outport: '<S516>/RX status' */

    L4_MABX_B.SFunction1_o5_nx = L4_MABX_P.RXstatus_Y0_o;



    /* SystemInitialize for Outport: '<S516>/RX time' */

    L4_MABX_B.SFunction1_o6_ez = L4_MABX_P.RXtime_Y0_ic;



    /* SystemInitialize for Outport: '<S516>/RX delta time' */

    L4_MABX_B.SFunction1_o7_j = L4_MABX_P.RXdeltatime_Y0_d;



    /* End of SystemInitialize for SubSystem: '<S515>/COGSOGRapidUpdate_00' */



    /* SystemInitialize for Enabled SubSystem: '<S515>/COGSOGRapidUpdate_1' */

    /* SystemInitialize for Outport: '<S517>/SID' */

    L4_MABX_B.SFunction1_o1_ar = L4_MABX_P.SID_Y0_j;



    /* SystemInitialize for Outport: '<S517>/COGReference' */

    L4_MABX_B.SFunction1_o2_p0 = L4_MABX_P.COGReference_Y0_p;



    /* SystemInitialize for Outport: '<S517>/CourseOverGround' */

    L4_MABX_B.SFunction1_o3_adq = L4_MABX_P.CourseOverGround_Y0_j;



    /* SystemInitialize for Outport: '<S517>/SpeedOverGround' */

    L4_MABX_B.SFunction1_o4_gf = L4_MABX_P.SpeedOverGround_Y0_a;



    /* SystemInitialize for Outport: '<S517>/RX status' */

    L4_MABX_B.SFunction1_o5_f1p = L4_MABX_P.RXstatus_Y0_od;



    /* SystemInitialize for Outport: '<S517>/RX time' */

    L4_MABX_B.SFunction1_o6_f = L4_MABX_P.RXtime_Y0_ld;



    /* SystemInitialize for Outport: '<S517>/RX delta time' */

    L4_MABX_B.SFunction1_o7_bu = L4_MABX_P.RXdeltatime_Y0_n1;



    /* End of SystemInitialize for SubSystem: '<S515>/COGSOGRapidUpdate_1' */



    /* SystemInitialize for Atomic SubSystem: '<S855>/CAN_TX_100ms' */

    /* SystemInitialize for Enabled SubSystem: '<S892>/Rolling_15_counter' */

    /* InitializeConditions for UnitDelay: '<S934>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE = L4_MABX_P.Unit_Delay_InitialCondition_bv;



    /* SystemInitialize for Outport: '<S934>/Rolling_15_counter' */

    L4_MABX_B.Unit_Delay = L4_MABX_P.Rolling_15_counter_Y0;



    /* End of SystemInitialize for SubSystem: '<S892>/Rolling_15_counter' */



    /* SystemInitialize for Enabled SubSystem: '<S914>/PropB_XPR_FC' */

    /* SystemInitialize for Outport: '<S916>/TX status' */

    L4_MABX_B.SFunction1_o1_n = L4_MABX_P.TXstatus_Y0_o;



    /* SystemInitialize for Outport: '<S916>/TX time' */

    L4_MABX_B.SFunction1_o2_du = L4_MABX_P.TXtime_Y0_jw;



    /* SystemInitialize for Outport: '<S916>/TX delta time' */

    L4_MABX_B.SFunction1_o3_b1 = L4_MABX_P.TXdeltatime_Y0_n;



    /* SystemInitialize for Outport: '<S916>/TX delay time' */

    L4_MABX_B.SFunction1_o4_o = L4_MABX_P.TXdelaytime_Y0_k;



    /* End of SystemInitialize for SubSystem: '<S914>/PropB_XPR_FC' */



    /* SystemInitialize for Enabled SubSystem: '<S915>/PropB_XPR_FC' */

    /* SystemInitialize for Outport: '<S917>/TX status' */

    L4_MABX_B.SFunction1_o1_fy = L4_MABX_P.TXstatus_Y0_j;



    /* SystemInitialize for Outport: '<S917>/TX time' */

    L4_MABX_B.SFunction1_o2_l = L4_MABX_P.TXtime_Y0_e;



    /* SystemInitialize for Outport: '<S917>/TX delta time' */

    L4_MABX_B.SFunction1_o3_f0 = L4_MABX_P.TXdeltatime_Y0_nq;



    /* SystemInitialize for Outport: '<S917>/TX delay time' */

    L4_MABX_B.SFunction1_o4_p = L4_MABX_P.TXdelaytime_Y0_gr;



    /* End of SystemInitialize for SubSystem: '<S915>/PropB_XPR_FC' */



    /* SystemInitialize for Enabled SubSystem: '<S944>/Std_PosRapidUpdate_01' */

    /* SystemInitialize for Outport: '<S945>/TX status' */

    L4_MABX_B.SFunction1_o1_lh = L4_MABX_P.TXstatus_Y0_c1;



    /* SystemInitialize for Outport: '<S945>/TX time' */

    L4_MABX_B.SFunction1_o2_b0 = L4_MABX_P.TXtime_Y0_i;



    /* SystemInitialize for Outport: '<S945>/TX delta time' */

    L4_MABX_B.SFunction1_o3_bz = L4_MABX_P.TXdeltatime_Y0_m;



    /* SystemInitialize for Outport: '<S945>/TX delay time' */

    L4_MABX_B.SFunction1_o4_n3 = L4_MABX_P.TXdelaytime_Y0_h;



    /* End of SystemInitialize for SubSystem: '<S944>/Std_PosRapidUpdate_01' */



    /* SystemInitialize for Enabled SubSystem: '<S894>/CCVS1_00' */

    /* SystemInitialize for Outport: '<S896>/TX status' */

    L4_MABX_B.SFunction1_o1_c = L4_MABX_P.TXstatus_Y0_a;



    /* SystemInitialize for Outport: '<S896>/TX time' */

    L4_MABX_B.SFunction1_o2_oc = L4_MABX_P.TXtime_Y0_l;



    /* SystemInitialize for Outport: '<S896>/TX delta time' */

    L4_MABX_B.SFunction1_o3_h = L4_MABX_P.TXdeltatime_Y0_o;



    /* SystemInitialize for Outport: '<S896>/TX delay time' */

    L4_MABX_B.SFunction1_o4_hr = L4_MABX_P.TXdelaytime_Y0_p;



    /* End of SystemInitialize for SubSystem: '<S894>/CCVS1_00' */



    /* SystemInitialize for Enabled SubSystem: '<S895>/CCVS1_00' */

    /* SystemInitialize for Outport: '<S897>/TX status' */

    L4_MABX_B.SFunction1_o1_i = L4_MABX_P.TXstatus_Y0_p;



    /* SystemInitialize for Outport: '<S897>/TX time' */

    L4_MABX_B.SFunction1_o2_gv = L4_MABX_P.TXtime_Y0_j;



    /* SystemInitialize for Outport: '<S897>/TX delta time' */

    L4_MABX_B.SFunction1_o3_j = L4_MABX_P.TXdeltatime_Y0_f;



    /* SystemInitialize for Outport: '<S897>/TX delay time' */

    L4_MABX_B.SFunction1_o4_fm = L4_MABX_P.TXdelaytime_Y0_e;



    /* End of SystemInitialize for SubSystem: '<S895>/CCVS1_00' */



    /* SystemInitialize for Enabled SubSystem: '<S898>/PropB_REAX_5_E4' */

    /* SystemInitialize for Outport: '<S900>/TX status' */

    L4_MABX_B.SFunction1_o1_a3 = L4_MABX_P.TXstatus_Y0_c;



    /* SystemInitialize for Outport: '<S900>/TX time' */

    L4_MABX_B.SFunction1_o2_ob = L4_MABX_P.TXtime_Y0_f;



    /* SystemInitialize for Outport: '<S900>/TX delta time' */

    L4_MABX_B.SFunction1_o3_bj = L4_MABX_P.TXdeltatime_Y0_a;



    /* SystemInitialize for Outport: '<S900>/TX delay time' */

    L4_MABX_B.SFunction1_o4_kp = L4_MABX_P.TXdelaytime_Y0_j;



    /* End of SystemInitialize for SubSystem: '<S898>/PropB_REAX_5_E4' */



    /* SystemInitialize for Enabled SubSystem: '<S899>/PropB_REAX_5_E4' */

    /* SystemInitialize for Outport: '<S901>/TX status' */

    L4_MABX_B.SFunction1_o1_nz = L4_MABX_P.TXstatus_Y0_au;



    /* SystemInitialize for Outport: '<S901>/TX time' */

    L4_MABX_B.SFunction1_o2_ed = L4_MABX_P.TXtime_Y0_l2;



    /* SystemInitialize for Outport: '<S901>/TX delta time' */

    L4_MABX_B.SFunction1_o3_o = L4_MABX_P.TXdeltatime_Y0_h;



    /* SystemInitialize for Outport: '<S901>/TX delay time' */

    L4_MABX_B.SFunction1_o4_k = L4_MABX_P.TXdelaytime_Y0_f;



    /* End of SystemInitialize for SubSystem: '<S899>/PropB_REAX_5_E4' */



    /* SystemInitialize for Enabled SubSystem: '<S918>/Std_COGSOGRapidUpdate_01' */

    /* SystemInitialize for Outport: '<S919>/TX status' */

    L4_MABX_B.SFunction1_o1_oy = L4_MABX_P.TXstatus_Y0_p3;



    /* SystemInitialize for Outport: '<S919>/TX time' */

    L4_MABX_B.SFunction1_o2_jm = L4_MABX_P.TXtime_Y0_g;



    /* SystemInitialize for Outport: '<S919>/TX delta time' */

    L4_MABX_B.SFunction1_o3_lx = L4_MABX_P.TXdeltatime_Y0_b;



    /* SystemInitialize for Outport: '<S919>/TX delay time' */

    L4_MABX_B.SFunction1_o4_fwb = L4_MABX_P.TXdelaytime_Y0_g0;



    /* End of SystemInitialize for SubSystem: '<S918>/Std_COGSOGRapidUpdate_01' */



    /* SystemInitialize for Enabled SubSystem: '<S920>/EBC1_TX' */

    /* SystemInitialize for Outport: '<S921>/TX status' */

    L4_MABX_B.SFunction1_o1_fc = L4_MABX_P.TXstatus_Y0_jr;



    /* SystemInitialize for Outport: '<S921>/TX time' */

    L4_MABX_B.SFunction1_o2_km = L4_MABX_P.TXtime_Y0_d;



    /* SystemInitialize for Outport: '<S921>/TX delta time' */

    L4_MABX_B.SFunction1_o3_bb = L4_MABX_P.TXdeltatime_Y0_c;



    /* SystemInitialize for Outport: '<S921>/TX delay time' */

    L4_MABX_B.SFunction1_o4_b = L4_MABX_P.TXdelaytime_Y0_i;



    /* End of SystemInitialize for SubSystem: '<S920>/EBC1_TX' */

    /* End of SystemInitialize for SubSystem: '<S855>/CAN_TX_100ms' */



    /* SystemInitialize for Atomic SubSystem: '<S855>/CAN_TX_10ms' */

    /* InitializeConditions for UnitDelay: '<S1012>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_mr = L4_MABX_P.Unit_Delay_InitialCondition_mj;



    /* InitializeConditions for UnitDelay: '<S1013>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_c = L4_MABX_P.UnitDelay_InitialCondition_le;



    /* SystemInitialize for Enabled SubSystem: '<S957>/ACCS' */

    /* SystemInitialize for Outport: '<S958>/TX status' */

    L4_MABX_B.SFunction1_o1_h = L4_MABX_P.TXstatus_Y0_m;



    /* SystemInitialize for Outport: '<S958>/TX time' */

    L4_MABX_B.SFunction1_o2_j = L4_MABX_P.TXtime_Y0_m;



    /* SystemInitialize for Outport: '<S958>/TX delta time' */

    L4_MABX_B.SFunction1_o3_br = L4_MABX_P.TXdeltatime_Y0_j;



    /* SystemInitialize for Outport: '<S958>/TX delay time' */

    L4_MABX_B.SFunction1_o4_d = L4_MABX_P.TXdelaytime_Y0_ed;



    /* End of SystemInitialize for SubSystem: '<S957>/ACCS' */



    /* SystemInitialize for Enabled SubSystem: '<S965>/EEC1_00' */

    /* SystemInitialize for Outport: '<S967>/TX status' */

    L4_MABX_B.SFunction1_o1_kl = L4_MABX_P.TXstatus_Y0_d;



    /* SystemInitialize for Outport: '<S967>/TX time' */

    L4_MABX_B.SFunction1_o2_o = L4_MABX_P.TXtime_Y0_fw;



    /* SystemInitialize for Outport: '<S967>/TX delta time' */

    L4_MABX_B.SFunction1_o3_bv = L4_MABX_P.TXdeltatime_Y0_p;



    /* SystemInitialize for Outport: '<S967>/TX delay time' */

    L4_MABX_B.SFunction1_o4_e5 = L4_MABX_P.TXdelaytime_Y0_c;



    /* End of SystemInitialize for SubSystem: '<S965>/EEC1_00' */



    /* SystemInitialize for Enabled SubSystem: '<S966>/EEC1_00' */

    /* SystemInitialize for Outport: '<S968>/TX status' */

    L4_MABX_B.SFunction1_o1_la = L4_MABX_P.TXstatus_Y0_n;



    /* SystemInitialize for Outport: '<S968>/TX time' */

    L4_MABX_B.SFunction1_o2_b = L4_MABX_P.TXtime_Y0_mj;



    /* SystemInitialize for Outport: '<S968>/TX delta time' */

    L4_MABX_B.SFunction1_o3_i1 = L4_MABX_P.TXdeltatime_Y0_iq;



    /* SystemInitialize for Outport: '<S968>/TX delay time' */

    L4_MABX_B.SFunction1_o4_mk = L4_MABX_P.TXdelaytime_Y0_a;



    /* End of SystemInitialize for SubSystem: '<S966>/EEC1_00' */



    /* SystemInitialize for Merge: '<S983>/Merge' */

    L4_MABX_B.Merge = L4_MABX_P.Merge_InitialOutput;



    /* SystemInitialize for Enabled SubSystem: '<S969>/PropB_REAX_1_E4' */

    /* SystemInitialize for Outport: '<S971>/TX status' */

    L4_MABX_B.SFunction1_o1_oc = L4_MABX_P.TXstatus_Y0_e;



    /* SystemInitialize for Outport: '<S971>/TX time' */

    L4_MABX_B.SFunction1_o2_c = L4_MABX_P.TXtime_Y0_p;



    /* SystemInitialize for Outport: '<S971>/TX delta time' */

    L4_MABX_B.SFunction1_o3_f = L4_MABX_P.TXdeltatime_Y0_e;



    /* SystemInitialize for Outport: '<S971>/TX delay time' */

    L4_MABX_B.SFunction1_o4_n = L4_MABX_P.TXdelaytime_Y0_ks;



    /* End of SystemInitialize for SubSystem: '<S969>/PropB_REAX_1_E4' */



    /* SystemInitialize for Enabled SubSystem: '<S970>/PropB_REAX_1_E4' */

    /* SystemInitialize for Outport: '<S972>/TX status' */

    L4_MABX_B.SFunction1_o1_m = L4_MABX_P.TXstatus_Y0_eu;



    /* SystemInitialize for Outport: '<S972>/TX time' */

    L4_MABX_B.SFunction1_o2_gj = L4_MABX_P.TXtime_Y0_k;



    /* SystemInitialize for Outport: '<S972>/TX delta time' */

    L4_MABX_B.SFunction1_o3_mj = L4_MABX_P.TXdeltatime_Y0_g;



    /* SystemInitialize for Outport: '<S972>/TX delay time' */

    L4_MABX_B.SFunction1_o4_j = L4_MABX_P.TXdelaytime_Y0_ho;



    /* End of SystemInitialize for SubSystem: '<S970>/PropB_REAX_1_E4' */



    /* SystemInitialize for Enabled SubSystem: '<S979>/VDC2_0B' */

    /* SystemInitialize for Outport: '<S980>/TX status' */

    L4_MABX_B.SFunction1_o1_l1 = L4_MABX_P.TXstatus_Y0_i;



    /* SystemInitialize for Outport: '<S980>/TX time' */

    L4_MABX_B.SFunction1_o2_er = L4_MABX_P.TXtime_Y0_jm;



    /* SystemInitialize for Outport: '<S980>/TX delta time' */

    L4_MABX_B.SFunction1_o3_bp = L4_MABX_P.TXdeltatime_Y0_g0;



    /* SystemInitialize for Outport: '<S980>/TX delay time' */

    L4_MABX_B.SFunction1_o4_m = L4_MABX_P.TXdelaytime_Y0_d;



    /* End of SystemInitialize for SubSystem: '<S979>/VDC2_0B' */

    /* End of SystemInitialize for SubSystem: '<S855>/CAN_TX_10ms' */



    /* SystemInitialize for Atomic SubSystem: '<S855>/CAN_TX_20ms' */

    /* InitializeConditions for UnitDelay: '<S1017>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_j5 = L4_MABX_P.Unit_Delay_InitialCondition_dp;



    /* InitializeConditions for UnitDelay: '<S1040>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_f3 = L4_MABX_P.Unit_Delay_InitialCondition_ir;



    /* InitializeConditions for UnitDelay: '<S1041>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_em = L4_MABX_P.UnitDelay_InitialCondition_b;



    /* SystemInitialize for Enabled SubSystem: '<S1024>/PropB_XBR_B3' */

    /* SystemInitialize for Outport: '<S1025>/TX status' */

    L4_MABX_B.SFunction1_o1_jl = L4_MABX_P.TXstatus_Y0_av;



    /* SystemInitialize for Outport: '<S1025>/TX time' */

    L4_MABX_B.SFunction1_o2_ph = L4_MABX_P.TXtime_Y0_f4;



    /* SystemInitialize for Outport: '<S1025>/TX delta time' */

    L4_MABX_B.SFunction1_o3_b = L4_MABX_P.TXdeltatime_Y0_ct;



    /* SystemInitialize for Outport: '<S1025>/TX delay time' */

    L4_MABX_B.SFunction1_o4_g = L4_MABX_P.TXdelaytime_Y0_kk;



    /* End of SystemInitialize for SubSystem: '<S1024>/PropB_XBR_B3' */



    /* SystemInitialize for Enabled SubSystem: '<S1026>/PropB_Bendix_2C2_XPR' */

    /* SystemInitialize for Outport: '<S1027>/TX status' */

    L4_MABX_B.SFunction1_o1_e = L4_MABX_P.TXstatus_Y0_pq;



    /* SystemInitialize for Outport: '<S1027>/TX time' */

    L4_MABX_B.SFunction1_o2_g = L4_MABX_P.TXtime_Y0_fx;



    /* SystemInitialize for Outport: '<S1027>/TX delta time' */

    L4_MABX_B.SFunction1_o3_d = L4_MABX_P.TXdeltatime_Y0_gj;



    /* SystemInitialize for Outport: '<S1027>/TX delay time' */

    L4_MABX_B.SFunction1_o4_fw = L4_MABX_P.TXdelaytime_Y0_l;



    /* End of SystemInitialize for SubSystem: '<S1026>/PropB_Bendix_2C2_XPR' */



    /* SystemInitialize for Enabled SubSystem: '<S1034>/Std_OdometryData' */

    /* SystemInitialize for Outport: '<S1035>/TX status' */

    L4_MABX_B.SFunction1_o1_b = L4_MABX_P.TXstatus_Y0_ag;



    /* SystemInitialize for Outport: '<S1035>/TX time' */

    L4_MABX_B.SFunction1_o2_f = L4_MABX_P.TXtime_Y0_fu;



    /* SystemInitialize for Outport: '<S1035>/TX delta time' */

    L4_MABX_B.SFunction1_o3_ed = L4_MABX_P.TXdeltatime_Y0_nc;



    /* SystemInitialize for Outport: '<S1035>/TX delay time' */

    L4_MABX_B.SFunction1_o4_fk = L4_MABX_P.TXdelaytime_Y0_en;



    /* End of SystemInitialize for SubSystem: '<S1034>/Std_OdometryData' */

    /* End of SystemInitialize for SubSystem: '<S855>/CAN_TX_20ms' */



    /* SystemInitialize for Atomic SubSystem: '<S855>/CAN_TX_5000ms' */

    /* InitializeConditions for UnitDelay: '<S1055>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_a = L4_MABX_P.Unit_Delay_InitialCondition_ew;



    /* InitializeConditions for UnitDelay: '<S1056>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_a = L4_MABX_P.UnitDelay_InitialCondition_j;



    /* SystemInitialize for Enabled SubSystem: '<S1049>/RQST_13_E4' */

    /* SystemInitialize for Outport: '<S1051>/TX status' */

    L4_MABX_B.SFunction1_o1_p = L4_MABX_P.TXstatus_Y0_h;



    /* SystemInitialize for Outport: '<S1051>/TX time' */

    L4_MABX_B.SFunction1_o2_k = L4_MABX_P.TXtime_Y0_gk;



    /* SystemInitialize for Outport: '<S1051>/TX delta time' */

    L4_MABX_B.SFunction1_o3_i = L4_MABX_P.TXdeltatime_Y0_eb;



    /* SystemInitialize for Outport: '<S1051>/TX delay time' */

    L4_MABX_B.SFunction1_o4_e = L4_MABX_P.TXdelaytime_Y0_b;



    /* End of SystemInitialize for SubSystem: '<S1049>/RQST_13_E4' */

    /* End of SystemInitialize for SubSystem: '<S855>/CAN_TX_5000ms' */



    /* SystemInitialize for Enabled SubSystem: '<S646>/TC1_03_05' */

    /* SystemInitialize for Outport: '<S647>/SPN681_TransGearShiftInhibitReq' */

    L4_MABX_B.SFunction1_o1_iz = L4_MABX_P.SPN681_TransGearShiftInhibitReq;



    /* SystemInitialize for Outport: '<S647>/SPN682_TransTrqConvLockupDisReq' */

    L4_MABX_B.SFunction1_o2_k5 = L4_MABX_P.SPN682_TransTrqConvLockupDisReq;



    /* SystemInitialize for Outport: '<S647>/SPN683_DisengageDrivelineReq' */

    L4_MABX_B.SFunction1_o3_edr = L4_MABX_P.SPN683_DisengageDrivelineReq_Y0;



    /* SystemInitialize for Outport: '<S647>/SPN4242_TransRevGearShiftInhibRq' */

    L4_MABX_B.SFunction1_o4_lb = L4_MABX_P.SPN4242_TransRevGearShiftInhibR;



    /* SystemInitialize for Outport: '<S647>/SPN684_RequestedPercClutchSlip' */

    L4_MABX_B.SFunction1_o5_n = L4_MABX_P.SPN684_RequestedPercClutchSlip_;



    /* SystemInitialize for Outport: '<S647>/SPN525_TransRequestedGear' */

    L4_MABX_B.SFunction1_o6_b = L4_MABX_P.SPN525_TransRequestedGear_Y0;



    /* SystemInitialize for Outport: '<S647>/SPN685_DisengageDiffLockRqFrAx1' */

    L4_MABX_B.SFunction1_o7_c = L4_MABX_P.SPN685_DisengageDiffLockRqFrAx1;



    /* SystemInitialize for Outport: '<S647>/SPN686_DisengageDiffLockRqFrAx2' */

    L4_MABX_B.SFunction1_o8_l = L4_MABX_P.SPN686_DisengageDiffLockRqFrAx2;



    /* SystemInitialize for Outport: '<S647>/SPN687_DisengageDiffLockRqRrAx1' */

    L4_MABX_B.SFunction1_o9_j = L4_MABX_P.SPN687_DisengageDiffLockRqRrAx1;



    /* SystemInitialize for Outport: '<S647>/SPN688_DisengageDiffLockRqRrAx2' */

    L4_MABX_B.SFunction1_o10_h = L4_MABX_P.SPN688_DisengageDiffLockRqRrAx2;



    /* SystemInitialize for Outport: '<S647>/SPN689_DisengageDiffLockRqC' */

    L4_MABX_B.SFunction1_o11 = L4_MABX_P.SPN689_DisengageDiffLockRqC_Y0;



    /* SystemInitialize for Outport: '<S647>/SPN690_DisengageDiffLockRqCF' */

    L4_MABX_B.SFunction1_o12 = L4_MABX_P.SPN690_DisengageDiffLockRqCF_Y0;



    /* SystemInitialize for Outport: '<S647>/SPN691_DisengageDiffLockRqCR' */

    L4_MABX_B.SFunction1_o13 = L4_MABX_P.SPN691_DisengageDiffLockRqCR_Y0;



    /* SystemInitialize for Outport: '<S647>/SPN5762_TransLoadRedInhibitRq' */

    L4_MABX_B.SFunction1_o14 = L4_MABX_P.SPN5762_TransLoadRedInhibitRq_Y;



    /* SystemInitialize for Outport: '<S647>/SPN1852_TransmissionMode1' */

    L4_MABX_B.SFunction1_o15 = L4_MABX_P.SPN1852_TransmissionMode1_Y0;



    /* SystemInitialize for Outport: '<S647>/SPN1853_TransmissionMode2' */

    L4_MABX_B.SFunction1_o16 = L4_MABX_P.SPN1853_TransmissionMode2_Y0;



    /* SystemInitialize for Outport: '<S647>/SPN1854_TransmissionMode3' */

    L4_MABX_B.SFunction1_o17 = L4_MABX_P.SPN1854_TransmissionMode3_Y0;



    /* SystemInitialize for Outport: '<S647>/SPN1855_TransmissionMode4' */

    L4_MABX_B.SFunction1_o18 = L4_MABX_P.SPN1855_TransmissionMode4_Y0;



    /* SystemInitialize for Outport: '<S647>/SPN7695_TransAutoNeutralRequest' */

    L4_MABX_B.SFunction1_o19 = L4_MABX_P.SPN7695_TransAutoNeutralRequest;



    /* SystemInitialize for Outport: '<S647>/SPN4255_TransRequestedLaunchGear' */

    L4_MABX_B.SFunction1_o20 = L4_MABX_P.SPN4255_TransRequestedLaunchGea;



    /* SystemInitialize for Outport: '<S647>/SPN2985_TransShiftSelDispModeSw' */

    L4_MABX_B.SFunction1_o21 = L4_MABX_P.SPN2985_TransShiftSelDispModeSw;



    /* SystemInitialize for Outport: '<S647>/SPN4246_TransmissionMode5' */

    L4_MABX_B.SFunction1_o22 = L4_MABX_P.SPN4246_TransmissionMode5_Y0;



    /* SystemInitialize for Outport: '<S647>/SPN4247_TransmissionMode6' */

    L4_MABX_B.SFunction1_o23 = L4_MABX_P.SPN4247_TransmissionMode6_Y0;



    /* SystemInitialize for Outport: '<S647>/SPN4248_TransmissionMode7' */

    L4_MABX_B.SFunction1_o24 = L4_MABX_P.SPN4248_TransmissionMode7_Y0;



    /* SystemInitialize for Outport: '<S647>/SPN4249_TransmissionMode8' */

    L4_MABX_B.SFunction1_o25 = L4_MABX_P.SPN4249_TransmissionMode8_Y0;



    /* SystemInitialize for Outport: '<S647>/RX status' */

    L4_MABX_B.SFunction1_o26 = L4_MABX_P.RXstatus_Y0_n5k;



    /* SystemInitialize for Outport: '<S647>/RX time' */

    L4_MABX_B.SFunction1_o27 = L4_MABX_P.RXtime_Y0_pt;



    /* SystemInitialize for Outport: '<S647>/RX delta time' */

    L4_MABX_B.SFunction1_o28 = L4_MABX_P.RXdeltatime_Y0_kp;



    /* End of SystemInitialize for SubSystem: '<S646>/TC1_03_05' */



    /* SystemInitialize for Atomic SubSystem: '<S855>/CAN_TX_50ms' */

    /* SystemInitialize for Enabled SubSystem: '<S1060>/CCVS1_E3' */

    /* SystemInitialize for Outport: '<S1062>/TX status' */

    L4_MABX_B.SFunction1_o1_kr = L4_MABX_P.TXstatus_Y0_l;



    /* SystemInitialize for Outport: '<S1062>/TX time' */

    L4_MABX_B.SFunction1_o2_p = L4_MABX_P.TXtime_Y0_gj;



    /* SystemInitialize for Outport: '<S1062>/TX delta time' */

    L4_MABX_B.SFunction1_o3_m = L4_MABX_P.TXdeltatime_Y0_go;



    /* SystemInitialize for Outport: '<S1062>/TX delay time' */

    L4_MABX_B.SFunction1_o4_h = L4_MABX_P.TXdelaytime_Y0_et;



    /* End of SystemInitialize for SubSystem: '<S1060>/CCVS1_E3' */



    /* SystemInitialize for Enabled SubSystem: '<S1061>/TC1_03_05' */

    /* SystemInitialize for Outport: '<S1063>/TX status' */

    L4_MABX_B.SFunction1_o1_a = L4_MABX_P.TXstatus_Y0_k2;



    /* SystemInitialize for Outport: '<S1063>/TX time' */

    L4_MABX_B.SFunction1_o2_h = L4_MABX_P.TXtime_Y0_ce;



    /* SystemInitialize for Outport: '<S1063>/TX delta time' */

    L4_MABX_B.SFunction1_o3_e = L4_MABX_P.TXdeltatime_Y0_oa;



    /* SystemInitialize for Outport: '<S1063>/TX delay time' */

    L4_MABX_B.SFunction1_o4_f = L4_MABX_P.TXdelaytime_Y0_kz;



    /* End of SystemInitialize for SubSystem: '<S1061>/TC1_03_05' */

    /* End of SystemInitialize for SubSystem: '<S855>/CAN_TX_50ms' */



    /* SystemInitialize for Enabled SubSystem: '<S644>/SystemTime_01' */

    /* SystemInitialize for Outport: '<S645>/SID' */

    L4_MABX_B.SFunction1_o1_os = L4_MABX_P.SID_Y0_b;



    /* SystemInitialize for Outport: '<S645>/Source' */

    L4_MABX_B.SFunction1_o2_ly = L4_MABX_P.Source_Y0;



    /* SystemInitialize for Outport: '<S645>/Date' */

    L4_MABX_B.SFunction1_o3_g = L4_MABX_P.Date_Y0;



    /* SystemInitialize for Outport: '<S645>/Time' */

    L4_MABX_B.SFunction1_o4_hf = L4_MABX_P.Time_Y0;



    /* SystemInitialize for Outport: '<S645>/RX status' */

    L4_MABX_B.SFunction1_o5_g = L4_MABX_P.RXstatus_Y0_e2;



    /* SystemInitialize for Outport: '<S645>/RX time' */

    L4_MABX_B.SFunction1_o6_k = L4_MABX_P.RXtime_Y0_dm;



    /* SystemInitialize for Outport: '<S645>/RX delta time' */

    L4_MABX_B.SFunction1_o7_e = L4_MABX_P.RXdeltatime_Y0_fb;



    /* End of SystemInitialize for SubSystem: '<S644>/SystemTime_01' */



    /* SystemInitialize for Enabled SubSystem: '<S1073>/Std_SystemTime_01' */

    /* SystemInitialize for Outport: '<S1075>/TX status' */

    L4_MABX_B.SFunction1_o1_l = L4_MABX_P.TXstatus_Y0_dc;



    /* SystemInitialize for Outport: '<S1075>/TX time' */

    L4_MABX_B.SFunction1_o2_d = L4_MABX_P.TXtime_Y0_mc;



    /* SystemInitialize for Outport: '<S1075>/TX delta time' */

    L4_MABX_B.SFunction1_o3 = L4_MABX_P.TXdeltatime_Y0_ny;



    /* SystemInitialize for Outport: '<S1075>/TX delay time' */

    L4_MABX_B.SFunction1_o4 = L4_MABX_P.TXdelaytime_Y0_hu;



    /* End of SystemInitialize for SubSystem: '<S1073>/Std_SystemTime_01' */



    /* SystemInitialize for Triggered SubSystem: '<S1068>/CAN_TYPE1_TX_M1_C1' */

    /* SystemInitialize for Outport: '<S1070>/TX status' */

    L4_MABX_B.SFunction1_o1_o = L4_MABX_P.TXstatus_Y0_ih;



    /* SystemInitialize for Outport: '<S1070>/TX time' */

    L4_MABX_B.SFunction1_o2_a = L4_MABX_P.TXtime_Y0_ix;



    /* SystemInitialize for Outport: '<S1070>/TX delta time' */

    L4_MABX_B.SFunction1_o3_c = L4_MABX_P.TXdeltatime_Y0_iw;



    /* SystemInitialize for Outport: '<S1070>/TX delay time' */

    L4_MABX_B.SFunction1_o4_l = L4_MABX_P.TXdelaytime_Y0_o;



    /* End of SystemInitialize for SubSystem: '<S1068>/CAN_TYPE1_TX_M1_C1' */



    /* SystemInitialize for Triggered SubSystem: '<S1069>/CAN_TYPE1_TX_M1_C1' */

    /* SystemInitialize for Outport: '<S1071>/TX status' */

    L4_MABX_B.SFunction1_o1_j = L4_MABX_P.TXstatus_Y0_eu3;



    /* SystemInitialize for Outport: '<S1071>/TX time' */

    L4_MABX_B.SFunction1_o2_e = L4_MABX_P.TXtime_Y0_n;



    /* SystemInitialize for Outport: '<S1071>/TX delta time' */

    L4_MABX_B.SFunction1_o3_l = L4_MABX_P.TXdeltatime_Y0_e1;



    /* SystemInitialize for Outport: '<S1071>/TX delay time' */

    L4_MABX_B.SFunction1_o4_a = L4_MABX_P.TXdelaytime_Y0_p1;



    /* End of SystemInitialize for SubSystem: '<S1069>/CAN_TYPE1_TX_M1_C1' */



    /* SystemInitialize for Chart: '<S865>/Chart' */

    L4_MABX_DW.temporalCounter_i1_m = 0U;

    L4_MABX_DW.is_active_c4_SUB_ECU_L4_MABX_HW = 0U;

    L4_MABX_DW.is_c4_SUB_ECU_L4_MABX_HW_Interf = L4_MABX_IN_NO_ACTIVE_CHILD;



    /* SystemInitialize for Enabled SubSystem: '<S579>/GNSSDOPs_011' */

    /* SystemInitialize for Outport: '<S580>/SID' */

    L4_MABX_B.SFunction1_o1_hs = L4_MABX_P.SID_Y0_l;



    /* SystemInitialize for Outport: '<S580>/SetMode' */

    L4_MABX_B.SFunction1_o2_d0 = L4_MABX_P.SetMode_Y0;



    /* SystemInitialize for Outport: '<S580>/OpMode' */

    L4_MABX_B.SFunction1_o3_o4 = L4_MABX_P.OpMode_Y0;



    /* SystemInitialize for Outport: '<S580>/HDOP_' */

    L4_MABX_B.SFunction1_o4_j0 = L4_MABX_P.HDOP_Y0;



    /* SystemInitialize for Outport: '<S580>/VDOP' */

    L4_MABX_B.SFunction1_o5_nf = L4_MABX_P.VDOP_Y0;



    /* SystemInitialize for Outport: '<S580>/TDOP' */

    L4_MABX_B.SFunction1_o6_g4y = L4_MABX_P.TDOP_Y0;



    /* SystemInitialize for Outport: '<S580>/RX status' */

    L4_MABX_B.SFunction1_o7_l3 = L4_MABX_P.RXstatus_Y0_j;



    /* SystemInitialize for Outport: '<S580>/RX time' */

    L4_MABX_B.SFunction1_o8_es = L4_MABX_P.RXtime_Y0_c;



    /* SystemInitialize for Outport: '<S580>/RX delta time' */

    L4_MABX_B.SFunction1_o9_gd = L4_MABX_P.RXdeltatime_Y0_f;



    /* End of SystemInitialize for SubSystem: '<S579>/GNSSDOPs_011' */



    /* SystemInitialize for Enabled SubSystem: '<S579>/GNSSDOPs_1' */

    /* SystemInitialize for Outport: '<S581>/SID' */

    L4_MABX_B.SFunction1_o1_lx = L4_MABX_P.SID_Y0_k;



    /* SystemInitialize for Outport: '<S581>/SetMode' */

    L4_MABX_B.SFunction1_o2_ad5 = L4_MABX_P.SetMode_Y0_l;



    /* SystemInitialize for Outport: '<S581>/OpMode' */

    L4_MABX_B.SFunction1_o3_g5 = L4_MABX_P.OpMode_Y0_e;



    /* SystemInitialize for Outport: '<S581>/HDOP_' */

    L4_MABX_B.SFunction1_o4_iv = L4_MABX_P.HDOP_Y0_a;



    /* SystemInitialize for Outport: '<S581>/VDOP' */

    L4_MABX_B.SFunction1_o5_lw = L4_MABX_P.VDOP_Y0_d;



    /* SystemInitialize for Outport: '<S581>/TDOP' */

    L4_MABX_B.SFunction1_o6_nk = L4_MABX_P.TDOP_Y0_e;



    /* SystemInitialize for Outport: '<S581>/RX status' */

    L4_MABX_B.SFunction1_o7_ev = L4_MABX_P.RXstatus_Y0_lq;



    /* SystemInitialize for Outport: '<S581>/RX time' */

    L4_MABX_B.SFunction1_o8_lx = L4_MABX_P.RXtime_Y0_g;



    /* SystemInitialize for Outport: '<S581>/RX delta time' */

    L4_MABX_B.SFunction1_o9_d = L4_MABX_P.RXdeltatime_Y0_i;



    /* End of SystemInitialize for SubSystem: '<S579>/GNSSDOPs_1' */



    /* SystemInitialize for Atomic SubSystem: '<S65>/Task_20ms' */

    /* InitializeConditions for UnitDelay: '<S401>/Unit Delay1' */

    L4_MABX_DW.UnitDelay1_DSTATE = L4_MABX_P.UnitDelay1_InitialCondition_p;



    /* InitializeConditions for DiscreteIntegrator: '<S402>/LongitudnalPosition' */

    L4_MABX_DW.LongitudnalPosition_DSTATE = L4_MABX_B.InitialPosition;

    L4_MABX_DW.LongitudnalPosition_PrevResetSt = 2;



    /* InitializeConditions for DiscreteIntegrator: '<S402>/VehHeading' */

    L4_MABX_DW.VehHeading_DSTATE = L4_MABX_B.InitialHeading;

    L4_MABX_DW.VehHeading_PrevResetState = 2;



    /* InitializeConditions for DiscreteIntegrator: '<S402>/XPosition' */

    L4_MABX_DW.XPosition_DSTATE = L4_MABX_B.InitialXPosition;

    L4_MABX_DW.XPosition_PrevResetState = 2;



    /* InitializeConditions for DiscreteIntegrator: '<S402>/YPosition' */

    L4_MABX_DW.YPosition_DSTATE = L4_MABX_B.InitialYPosition;

    L4_MABX_DW.YPosition_PrevResetState = 2;



    /* End of SystemInitialize for SubSystem: '<S65>/Task_20ms' */



    /* SystemInitialize for S-Function (rti_commonblock): '<S414>/S-Function1' incorporates:

     *  SubSystem: '<S405>/Background_Task'

     */

    L4_MAB_Background_Task_Init();



    /* End of SystemInitialize for S-Function (rti_commonblock): '<S414>/S-Function1' */



    /* SystemInitialize for S-Function (rti_commonblock): '<S420>/S-Function1' incorporates:

     *  SubSystem: '<S405>/Interrupt_Task'

     */

    L4_MABX_Interrupt_Task_Init();



    /* End of SystemInitialize for S-Function (rti_commonblock): '<S420>/S-Function1' */



    /* SystemInitialize for Enabled SubSystem: '<S501>/AEBS1_A0' */

    /* SystemInitialize for Outport: '<S502>/AdvEmergencyBrkSysState' */

    L4_MABX_B.SFunction1_o1_jc = L4_MABX_P.AdvEmergencyBrkSysState_Y0;



    /* SystemInitialize for Outport: '<S502>/CollisionWarningLevel' */

    L4_MABX_B.SFunction1_o2_pw = L4_MABX_P.CollisionWarningLevel_Y0;



    /* SystemInitialize for Outport: '<S502>/RelObjctDetForAdvEmergBrakingSys' */

    L4_MABX_B.SFunction1_o3_km = L4_MABX_P.RelObjctDetForAdvEmergBrakingSy;



    /* SystemInitialize for Outport: '<S502>/BendOffProbabOfRelevantObject' */

    L4_MABX_B.SFunction1_o4_ke = L4_MABX_P.BendOffProbabOfRelevantObject_Y;



    /* SystemInitialize for Outport: '<S502>/TimeToCollisionWithRelevantObj' */

    L4_MABX_B.SFunction1_o5_pv = L4_MABX_P.TimeToCollisionWithRelevantObj_;



    /* SystemInitialize for Outport: '<S502>/RX status' */

    L4_MABX_B.SFunction1_o6_pv = L4_MABX_P.RXstatus_Y0_i;



    /* SystemInitialize for Outport: '<S502>/RX time' */

    L4_MABX_B.SFunction1_o7_jm = L4_MABX_P.RXtime_Y0_n5;



    /* SystemInitialize for Outport: '<S502>/RX delta time' */

    L4_MABX_B.SFunction1_o8_cl = L4_MABX_P.RXdeltatime_Y0_b;



    /* End of SystemInitialize for SubSystem: '<S501>/AEBS1_A0' */



    /* SystemInitialize for Enabled SubSystem: '<S507>/B2' */

    /* SystemInitialize for Outport: '<S508>/BrakeAppPressDemanded' */

    L4_MABX_B.SFunction1_o1_pc = L4_MABX_P.BrakeAppPressDemanded_Y0;



    /* SystemInitialize for Outport: '<S508>/BrakeSwitch2' */

    L4_MABX_B.SFunction1_o2_bz = L4_MABX_P.BrakeSwitch2_Y0;



    /* SystemInitialize for Outport: '<S508>/RX status' */

    L4_MABX_B.SFunction1_o3_o1 = L4_MABX_P.RXstatus_Y0_b;



    /* SystemInitialize for Outport: '<S508>/RX time' */

    L4_MABX_B.SFunction1_o4_md = L4_MABX_P.RXtime_Y0_f;



    /* SystemInitialize for Outport: '<S508>/RX delta time' */

    L4_MABX_B.SFunction1_o5_lj = L4_MABX_P.RXdeltatime_Y0_o;



    /* End of SystemInitialize for SubSystem: '<S507>/B2' */



    /* SystemInitialize for Enabled SubSystem: '<S509>/Tracks' */

    /* SystemInitialize for Outport: '<S510>/tr0_track_selection_status' */

    L4_MABX_B.SFunction1_o1_ly = L4_MABX_P.tr0_track_selection_status_Y0;



    /* SystemInitialize for Outport: '<S510>/tr0_corrected_lateral_distance' */

    L4_MABX_B.SFunction1_o2_fl = L4_MABX_P.tr0_corrected_lateral_distance_;



    /* SystemInitialize for Outport: '<S510>/tr1_track_selection_status' */

    L4_MABX_B.SFunction1_o3_os = L4_MABX_P.tr1_track_selection_status_Y0;



    /* SystemInitialize for Outport: '<S510>/tr1_corrected_lateral_distance' */

    L4_MABX_B.SFunction1_o4_dz = L4_MABX_P.tr1_corrected_lateral_distance_;



    /* SystemInitialize for Outport: '<S510>/tr2_track_selection_status' */

    L4_MABX_B.SFunction1_o5_pr = L4_MABX_P.tr2_track_selection_status_Y0;



    /* SystemInitialize for Outport: '<S510>/tr2_corrected_lateral_distance' */

    L4_MABX_B.SFunction1_o6_hf = L4_MABX_P.tr2_corrected_lateral_distance_;



    /* SystemInitialize for Outport: '<S510>/tr3_track_selection_status' */

    L4_MABX_B.SFunction1_o7_pz = L4_MABX_P.tr3_track_selection_status_Y0;



    /* SystemInitialize for Outport: '<S510>/tr3_corrected_lateral_distance' */

    L4_MABX_B.SFunction1_o8_g = L4_MABX_P.tr3_corrected_lateral_distance_;



    /* SystemInitialize for Outport: '<S510>/tr4_track_selection_status' */

    L4_MABX_B.SFunction1_o9_g5 = L4_MABX_P.tr4_track_selection_status_Y0;



    /* SystemInitialize for Outport: '<S510>/tr4_corrected_lateral_distance' */

    L4_MABX_B.SFunction1_o10_d5 = L4_MABX_P.tr4_corrected_lateral_distance_;



    /* SystemInitialize for Outport: '<S510>/tr5_track_selection_status' */

    L4_MABX_B.SFunction1_o11_by = L4_MABX_P.tr5_track_selection_status_Y0;



    /* SystemInitialize for Outport: '<S510>/tr5_corrected_lateral_distance' */

    L4_MABX_B.SFunction1_o12_b = L4_MABX_P.tr5_corrected_lateral_distance_;



    /* SystemInitialize for Outport: '<S510>/tr6_track_selection_status' */

    L4_MABX_B.SFunction1_o13_g0 = L4_MABX_P.tr6_track_selection_status_Y0;



    /* SystemInitialize for Outport: '<S510>/tr6_corrected_lateral_distance' */

    L4_MABX_B.SFunction1_o14_nc = L4_MABX_P.tr6_corrected_lateral_distance_;



    /* SystemInitialize for Outport: '<S510>/tr7_track_selection_status' */

    L4_MABX_B.SFunction1_o15_ag = L4_MABX_P.tr7_track_selection_status_Y0;



    /* SystemInitialize for Outport: '<S510>/tr7_corrected_lateral_distance' */

    L4_MABX_B.SFunction1_o16_c = L4_MABX_P.tr7_corrected_lateral_distance_;



    /* SystemInitialize for Outport: '<S510>/tr8_track_selection_status' */

    L4_MABX_B.SFunction1_o17_b = L4_MABX_P.tr8_track_selection_status_Y0;



    /* SystemInitialize for Outport: '<S510>/tr8_corrected_lateral_distance' */

    L4_MABX_B.SFunction1_o18_b = L4_MABX_P.tr8_corrected_lateral_distance_;



    /* SystemInitialize for Outport: '<S510>/tr9_track_selection_status' */

    L4_MABX_B.SFunction1_o19_n = L4_MABX_P.tr9_track_selection_status_Y0;



    /* SystemInitialize for Outport: '<S510>/tr9_corrected_lateral_distance' */

    L4_MABX_B.SFunction1_o20_j = L4_MABX_P.tr9_corrected_lateral_distance_;



    /* SystemInitialize for Outport: '<S510>/tr0_lateral_position' */

    L4_MABX_B.SFunction1_o21_e5 = L4_MABX_P.tr0_lateral_position_Y0;



    /* SystemInitialize for Outport: '<S510>/tr1_lateral_position' */

    L4_MABX_B.SFunction1_o22_f = L4_MABX_P.tr1_lateral_position_Y0;



    /* SystemInitialize for Outport: '<S510>/tr2_lateral_position' */

    L4_MABX_B.SFunction1_o23_e = L4_MABX_P.tr2_lateral_position_Y0;



    /* SystemInitialize for Outport: '<S510>/tr3_lateral_position' */

    L4_MABX_B.SFunction1_o24_g = L4_MABX_P.tr3_lateral_position_Y0;



    /* SystemInitialize for Outport: '<S510>/tr4_lateral_position' */

    L4_MABX_B.SFunction1_o25_b = L4_MABX_P.tr4_lateral_position_Y0;



    /* SystemInitialize for Outport: '<S510>/tr5_lateral_position' */

    L4_MABX_B.SFunction1_o26_l = L4_MABX_P.tr5_lateral_position_Y0;



    /* SystemInitialize for Outport: '<S510>/tr6_lateral_position' */

    L4_MABX_B.SFunction1_o27_h = L4_MABX_P.tr6_lateral_position_Y0;



    /* SystemInitialize for Outport: '<S510>/tr7_lateral_position' */

    L4_MABX_B.SFunction1_o28_f = L4_MABX_P.tr7_lateral_position_Y0;



    /* SystemInitialize for Outport: '<S510>/tr8_lateral_position' */

    L4_MABX_B.SFunction1_o29 = L4_MABX_P.tr8_lateral_position_Y0;



    /* SystemInitialize for Outport: '<S510>/tr9_lateral_position' */

    L4_MABX_B.SFunction1_o30 = L4_MABX_P.tr9_lateral_position_Y0;



    /* SystemInitialize for Outport: '<S510>/tr0_range' */

    L4_MABX_B.SFunction1_o31 = L4_MABX_P.tr0_range_Y0;



    /* SystemInitialize for Outport: '<S510>/tr1_range' */

    L4_MABX_B.SFunction1_o32 = L4_MABX_P.tr1_range_Y0;



    /* SystemInitialize for Outport: '<S510>/tr2_range' */

    L4_MABX_B.SFunction1_o33 = L4_MABX_P.tr2_range_Y0;



    /* SystemInitialize for Outport: '<S510>/tr3_range' */

    L4_MABX_B.SFunction1_o34 = L4_MABX_P.tr3_range_Y0;



    /* SystemInitialize for Outport: '<S510>/tr4_range' */

    L4_MABX_B.SFunction1_o35 = L4_MABX_P.tr4_range_Y0;



    /* SystemInitialize for Outport: '<S510>/tr5_range' */

    L4_MABX_B.SFunction1_o36 = L4_MABX_P.tr5_range_Y0;



    /* SystemInitialize for Outport: '<S510>/tr6_range' */

    L4_MABX_B.SFunction1_o37 = L4_MABX_P.tr6_range_Y0;



    /* SystemInitialize for Outport: '<S510>/tr7_range' */

    L4_MABX_B.SFunction1_o38 = L4_MABX_P.tr7_range_Y0;



    /* SystemInitialize for Outport: '<S510>/tr8_range' */

    L4_MABX_B.SFunction1_o39 = L4_MABX_P.tr8_range_Y0;



    /* SystemInitialize for Outport: '<S510>/tr9_range' */

    L4_MABX_B.SFunction1_o40 = L4_MABX_P.tr9_range_Y0;



    /* SystemInitialize for Outport: '<S510>/tr0_radar_confidence' */

    L4_MABX_B.SFunction1_o41 = L4_MABX_P.tr0_radar_confidence_Y0;



    /* SystemInitialize for Outport: '<S510>/tr1_radar_confidence' */

    L4_MABX_B.SFunction1_o42 = L4_MABX_P.tr1_radar_confidence_Y0;



    /* SystemInitialize for Outport: '<S510>/tr2_radar_confidence' */

    L4_MABX_B.SFunction1_o43 = L4_MABX_P.tr2_radar_confidence_Y0;



    /* SystemInitialize for Outport: '<S510>/tr3_radar_confidence' */

    L4_MABX_B.SFunction1_o44 = L4_MABX_P.tr3_radar_confidence_Y0;



    /* SystemInitialize for Outport: '<S510>/tr4_radar_confidence' */

    L4_MABX_B.SFunction1_o45 = L4_MABX_P.tr4_radar_confidence_Y0;



    /* SystemInitialize for Outport: '<S510>/tr5_radar_confidence' */

    L4_MABX_B.SFunction1_o46 = L4_MABX_P.tr5_radar_confidence_Y0;



    /* SystemInitialize for Outport: '<S510>/tr6_radar_confidence' */

    L4_MABX_B.SFunction1_o47 = L4_MABX_P.tr6_radar_confidence_Y0;



    /* SystemInitialize for Outport: '<S510>/tr7_radar_confidence' */

    L4_MABX_B.SFunction1_o48 = L4_MABX_P.tr7_radar_confidence_Y0;



    /* SystemInitialize for Outport: '<S510>/tr8_radar_confidence' */

    L4_MABX_B.SFunction1_o49 = L4_MABX_P.tr8_radar_confidence_Y0;



    /* SystemInitialize for Outport: '<S510>/tr9_radar_confidence' */

    L4_MABX_B.SFunction1_o50 = L4_MABX_P.tr9_radar_confidence_Y0;



    /* SystemInitialize for Outport: '<S510>/tr0_relative_velocitiy' */

    L4_MABX_B.SFunction1_o51 = L4_MABX_P.tr0_relative_velocitiy_Y0;



    /* SystemInitialize for Outport: '<S510>/tr0_acceleration_over_ground' */

    L4_MABX_B.SFunction1_o52 = L4_MABX_P.tr0_acceleration_over_ground_Y0;



    /* SystemInitialize for Outport: '<S510>/tr1_relative_velocitiy' */

    L4_MABX_B.SFunction1_o53 = L4_MABX_P.tr1_relative_velocitiy_Y0;



    /* SystemInitialize for Outport: '<S510>/tr1_acceleration_over_ground' */

    L4_MABX_B.SFunction1_o54 = L4_MABX_P.tr1_acceleration_over_ground_Y0;



    /* SystemInitialize for Outport: '<S510>/tr2_relative_velocitiy' */

    L4_MABX_B.SFunction1_o55 = L4_MABX_P.tr2_relative_velocitiy_Y0;



    /* SystemInitialize for Outport: '<S510>/tr2_acceleration_over_ground' */

    L4_MABX_B.SFunction1_o56 = L4_MABX_P.tr2_acceleration_over_ground_Y0;



    /* SystemInitialize for Outport: '<S510>/tr3_relative_velocitiy' */

    L4_MABX_B.SFunction1_o57 = L4_MABX_P.tr3_relative_velocitiy_Y0;



    /* SystemInitialize for Outport: '<S510>/tr3_acceleration_over_ground' */

    L4_MABX_B.SFunction1_o58 = L4_MABX_P.tr3_acceleration_over_ground_Y0;



    /* SystemInitialize for Outport: '<S510>/tr4_relative_velocitiy' */

    L4_MABX_B.SFunction1_o59 = L4_MABX_P.tr4_relative_velocitiy_Y0;



    /* SystemInitialize for Outport: '<S510>/tr4_acceleration_over_ground' */

    L4_MABX_B.SFunction1_o60 = L4_MABX_P.tr4_acceleration_over_ground_Y0;



    /* SystemInitialize for Outport: '<S510>/tr5_relative_velocitiy' */

    L4_MABX_B.SFunction1_o61 = L4_MABX_P.tr5_relative_velocitiy_Y0;



    /* SystemInitialize for Outport: '<S510>/tr5_acceleration_over_ground' */

    L4_MABX_B.SFunction1_o62 = L4_MABX_P.tr5_acceleration_over_ground_Y0;



    /* SystemInitialize for Outport: '<S510>/tr6_relative_velocitiy' */

    L4_MABX_B.SFunction1_o63 = L4_MABX_P.tr6_relative_velocitiy_Y0;



    /* SystemInitialize for Outport: '<S510>/tr6_acceleration_over_ground' */

    L4_MABX_B.SFunction1_o64 = L4_MABX_P.tr6_acceleration_over_ground_Y0;



    /* SystemInitialize for Outport: '<S510>/tr7_relative_velocitiy' */

    L4_MABX_B.SFunction1_o65 = L4_MABX_P.tr7_relative_velocitiy_Y0;



    /* SystemInitialize for Outport: '<S510>/tr7_acceleration_over_ground' */

    L4_MABX_B.SFunction1_o66 = L4_MABX_P.tr7_acceleration_over_ground_Y0;



    /* SystemInitialize for Outport: '<S510>/tr8_relative_velocitiy' */

    L4_MABX_B.SFunction1_o67 = L4_MABX_P.tr8_relative_velocitiy_Y0;



    /* SystemInitialize for Outport: '<S510>/tr8_acceleration_over_ground' */

    L4_MABX_B.SFunction1_o68 = L4_MABX_P.tr8_acceleration_over_ground_Y0;



    /* SystemInitialize for Outport: '<S510>/tr9_relative_velocitiy' */

    L4_MABX_B.SFunction1_o69 = L4_MABX_P.tr9_relative_velocitiy_Y0;



    /* SystemInitialize for Outport: '<S510>/tr9_acceleration_over_ground' */

    L4_MABX_B.SFunction1_o70 = L4_MABX_P.tr9_acceleration_over_ground_Y0;



    /* SystemInitialize for Outport: '<S510>/track_multiplexor' */

    L4_MABX_B.SFunction1_o71 = L4_MABX_P.track_multiplexor_Y0;



    /* SystemInitialize for Outport: '<S510>/RX status' */

    L4_MABX_B.SFunction1_o72 = L4_MABX_P.RXstatus_Y0_m;



    /* SystemInitialize for Outport: '<S510>/RX time' */

    L4_MABX_B.SFunction1_o73 = L4_MABX_P.RXtime_Y0_ft;



    /* SystemInitialize for Outport: '<S510>/RX delta time' */

    L4_MABX_B.SFunction1_o74 = L4_MABX_P.RXdeltatime_Y0_ew;



    /* End of SystemInitialize for SubSystem: '<S509>/Tracks' */



    /* SystemInitialize for Enabled SubSystem: '<S520>/EBC1_0B' */

    /* SystemInitialize for Outport: '<S521>/ASREngCtrlActive' */

    L4_MABX_B.SFunction1_o1_bq = L4_MABX_P.ASREngCtrlActive_Y0;



    /* SystemInitialize for Outport: '<S521>/ASRBrakeCtrlActive' */

    L4_MABX_B.SFunction1_o2_pl3 = L4_MABX_P.ASRBrakeCtrlActive_Y0;



    /* SystemInitialize for Outport: '<S521>/AntiLockBrakingActive' */

    L4_MABX_B.SFunction1_o3_bzd = L4_MABX_P.AntiLockBrakingActive_Y0;



    /* SystemInitialize for Outport: '<S521>/EBSBrakeSwitch' */

    L4_MABX_B.SFunction1_o4_cj = L4_MABX_P.EBSBrakeSwitch_Y0;



    /* SystemInitialize for Outport: '<S521>/BrakePedalPos' */

    L4_MABX_B.SFunction1_o5_a = L4_MABX_P.BrakePedalPos_Y0;



    /* SystemInitialize for Outport: '<S521>/ABSOffroadSwitch' */

    L4_MABX_B.SFunction1_o6_nt = L4_MABX_P.ABSOffroadSwitch_Y0;



    /* SystemInitialize for Outport: '<S521>/ASROffroadSwitch' */

    L4_MABX_B.SFunction1_o7_lm = L4_MABX_P.ASROffroadSwitch_Y0;



    /* SystemInitialize for Outport: '<S521>/ASRHillHolderSwitch' */

    L4_MABX_B.SFunction1_o8_n5 = L4_MABX_P.ASRHillHolderSwitch_Y0;



    /* SystemInitialize for Outport: '<S521>/TractionCtrlOverrideSwitch' */

    L4_MABX_B.SFunction1_o9_dw = L4_MABX_P.TractionCtrlOverrideSwitch_Y0;



    /* SystemInitialize for Outport: '<S521>/AccelInterlockSwitch' */

    L4_MABX_B.SFunction1_o10_by = L4_MABX_P.AccelInterlockSwitch_Y0;



    /* SystemInitialize for Outport: '<S521>/EngDerateSwitch' */

    L4_MABX_B.SFunction1_o11_m = L4_MABX_P.EngDerateSwitch_Y0;



    /* SystemInitialize for Outport: '<S521>/EngAuxShutdownSwitch' */

    L4_MABX_B.SFunction1_o12_l = L4_MABX_P.EngAuxShutdownSwitch_Y0;



    /* SystemInitialize for Outport: '<S521>/RemoteAccelEnableSwitch' */

    L4_MABX_B.SFunction1_o13_d = L4_MABX_P.RemoteAccelEnableSwitch_Y0;



    /* SystemInitialize for Outport: '<S521>/EngRetarderSelection' */

    L4_MABX_B.SFunction1_o14_n = L4_MABX_P.EngRetarderSelection_Y0;



    /* SystemInitialize for Outport: '<S521>/ABSFullyOperational' */

    L4_MABX_B.SFunction1_o15_a0 = L4_MABX_P.ABSFullyOperational_Y0;



    /* SystemInitialize for Outport: '<S521>/EBSRedWarningSignal' */

    L4_MABX_B.SFunction1_o16_k = L4_MABX_P.EBSRedWarningSignal_Y0;



    /* SystemInitialize for Outport: '<S521>/ABS_EBSAmberWarningSignal' */

    L4_MABX_B.SFunction1_o17_j = L4_MABX_P.ABS_EBSAmberWarningSignal_Y0;



    /* SystemInitialize for Outport: '<S521>/ATC_ASRInformationSignal' */

    L4_MABX_B.SFunction1_o18_d = L4_MABX_P.ATC_ASRInformationSignal_Y0;



    /* SystemInitialize for Outport: '<S521>/SrcAddrssOfCtrllngDvcFrBrkCntrl' */

    L4_MABX_B.SFunction1_o19_k = L4_MABX_P.SrcAddrssOfCtrllngDvcFrBrkCntrl;



    /* SystemInitialize for Outport: '<S521>/HaltBrakeSwitch' */

    L4_MABX_B.SFunction1_o20_h = L4_MABX_P.HaltBrakeSwitch_Y0;



    /* SystemInitialize for Outport: '<S521>/TrailerABSStatus' */

    L4_MABX_B.SFunction1_o21_l = L4_MABX_P.TrailerABSStatus_Y0;



    /* SystemInitialize for Outport: '<S521>/TrctrMntdTrilerABSWarningSignal' */

    L4_MABX_B.SFunction1_o22_i = L4_MABX_P.TrctrMntdTrilerABSWarningSignal;



    /* SystemInitialize for Outport: '<S521>/RX status' */

    L4_MABX_B.SFunction1_o23_n = L4_MABX_P.RXstatus_Y0_i2;



    /* SystemInitialize for Outport: '<S521>/RX time' */

    L4_MABX_B.SFunction1_o24_o = L4_MABX_P.RXtime_Y0_h;



    /* SystemInitialize for Outport: '<S521>/RX delta time' */

    L4_MABX_B.SFunction1_o25_m = L4_MABX_P.RXdeltatime_Y0_l;



    /* End of SystemInitialize for SubSystem: '<S520>/EBC1_0B' */



    /* SystemInitialize for Enabled SubSystem: '<S573>/EEC2_001' */

    /* SystemInitialize for Outport: '<S574>/SPN558_AccelPed1LowIdlSwitch' */

    L4_MABX_B.SFunction1_o1_a0 = L4_MABX_P.SPN558_AccelPed1LowIdlSwitch_Y0;



    /* SystemInitialize for Outport: '<S574>/SPN559_AccelPedKickdownSw' */

    L4_MABX_B.SFunction1_o2_m4 = L4_MABX_P.SPN559_AccelPedKickdownSw_Y0;



    /* SystemInitialize for Outport: '<S574>/SPN1437_RoadSpeedLimitStatus' */

    L4_MABX_B.SFunction1_o3_k = L4_MABX_P.SPN1437_RoadSpeedLimitStatus_Y0;



    /* SystemInitialize for Outport: '<S574>/SPN2970_AccelPed2LowIdlSwitch' */

    L4_MABX_B.SFunction1_o4_nu = L4_MABX_P.SPN2970_AccelPed2LowIdlSwitch_Y;



    /* SystemInitialize for Outport: '<S574>/SPN91_AccelPedPos1' */

    L4_MABX_B.SFunction1_o5_e0 = L4_MABX_P.SPN91_AccelPedPos1_Y0;



    /* SystemInitialize for Outport: '<S574>/SPN92_EngPercLoadAtCurrSpd' */

    L4_MABX_B.SFunction1_o6_j = L4_MABX_P.SPN92_EngPercLoadAtCurrSpd_Y0;



    /* SystemInitialize for Outport: '<S574>/SPN974_RemAccelPedalPosition' */

    L4_MABX_B.SFunction1_o7_b = L4_MABX_P.SPN974_RemAccelPedalPosition_Y0;



    /* SystemInitialize for Outport: '<S574>/SPN29_AccelPedPos2' */

    L4_MABX_B.SFunction1_o8_py = L4_MABX_P.SPN29_AccelPedPos2_Y0;



    /* SystemInitialize for Outport: '<S574>/SPN2979_VehAccelRateLimStatus' */

    L4_MABX_B.SFunction1_o9_iy = L4_MABX_P.SPN2979_VehAccelRateLimStatus_Y;



    /* SystemInitialize for Outport: '<S574>/SPN5021_MomEngMaxPwrEnFdbk' */

    L4_MABX_B.SFunction1_o10_m = L4_MABX_P.SPN5021_MomEngMaxPwrEnFdbk_Y0;



    /* SystemInitialize for Outport: '<S574>/SPN5399_DPFThermMgmtActive' */

    L4_MABX_B.SFunction1_o11_c = L4_MABX_P.SPN5399_DPFThermMgmtActive_Y0;



    /* SystemInitialize for Outport: '<S574>/SPN5400_SCRThermMgmtActive' */

    L4_MABX_B.SFunction1_o12_i = L4_MABX_P.SPN5400_SCRThermMgmtActive_Y0;



    /* SystemInitialize for Outport: '<S574>/SPN3357_ActMaxAvailEngPercTrq' */

    L4_MABX_B.SFunction1_o13_gy = L4_MABX_P.SPN3357_ActMaxAvailEngPercTrq_Y;



    /* SystemInitialize for Outport: '<S574>/SPN5398_EstPumpingPercentTorque' */

    L4_MABX_B.SFunction1_o14_g = L4_MABX_P.SPN5398_EstPumpingPercentTorque;



    /* SystemInitialize for Outport: '<S574>/RX status' */

    L4_MABX_B.SFunction1_o15_d = L4_MABX_P.RXstatus_Y0_d;



    /* SystemInitialize for Outport: '<S574>/RX time' */

    L4_MABX_B.SFunction1_o16_e = L4_MABX_P.RXtime_Y0_al;



    /* SystemInitialize for Outport: '<S574>/RX delta time' */

    L4_MABX_B.SFunction1_o17_l = L4_MABX_P.RXdeltatime_Y0_h;



    /* End of SystemInitialize for SubSystem: '<S573>/EEC2_001' */



    /* SystemInitialize for Enabled SubSystem: '<S614>/CAN_TYPE1_RX_M1_C1' */

    /* SystemInitialize for Outport: '<S618>/EPBPCMInhibitStatusFeedback' */

    L4_MABX_B.SFunction1_o1_nn = L4_MABX_P.EPBPCMInhibitStatusFeedback_Y0;



    /* SystemInitialize for Outport: '<S618>/EPBPCMManualStatusFeedback' */

    L4_MABX_B.SFunction1_o2_pn = L4_MABX_P.EPBPCMManualStatusFeedback_Y0;



    /* SystemInitialize for Outport: '<S618>/RX status' */

    L4_MABX_B.SFunction1_o3_jj = L4_MABX_P.RXstatus_Y0_e0;



    /* SystemInitialize for Outport: '<S618>/RX time' */

    L4_MABX_B.SFunction1_o4_i = L4_MABX_P.RXtime_Y0_d5;



    /* SystemInitialize for Outport: '<S618>/RX delta time' */

    L4_MABX_B.SFunction1_o5_k = L4_MABX_P.RXdeltatime_Y0_ee;



    /* End of SystemInitialize for SubSystem: '<S614>/CAN_TYPE1_RX_M1_C1' */



    /* SystemInitialize for Enabled SubSystem: '<S615>/CAN_TYPE1_RX_M1_C2' */

    /* SystemInitialize for Outport: '<S619>/EPBPCMInhibitStatusFeedback' */

    L4_MABX_B.SFunction1_o1_lae = L4_MABX_P.EPBPCMInhibitStatusFeedback_Y_e;



    /* SystemInitialize for Outport: '<S619>/EPBPCMManualStatusFeedback' */

    L4_MABX_B.SFunction1_o2_bh = L4_MABX_P.EPBPCMManualStatusFeedback_Y0_g;



    /* SystemInitialize for Outport: '<S619>/RX status' */

    L4_MABX_B.SFunction1_o3_gz = L4_MABX_P.RXstatus_Y0_h;



    /* SystemInitialize for Outport: '<S619>/RX time' */

    L4_MABX_B.SFunction1_o4_hf3 = L4_MABX_P.RXtime_Y0_cf;



    /* SystemInitialize for Outport: '<S619>/RX delta time' */

    L4_MABX_B.SFunction1_o5_p5 = L4_MABX_P.RXdeltatime_Y0_oy;



    /* End of SystemInitialize for SubSystem: '<S615>/CAN_TYPE1_RX_M1_C2' */



    /* SystemInitialize for Enabled SubSystem: '<S616>/CAN_TYPE1_RX_M2_C1' */

    /* SystemInitialize for Outport: '<S620>/EPBPCMInhibitStatusFeedback' */

    L4_MABX_B.SFunction1_o1_n0 = L4_MABX_P.EPBPCMInhibitStatusFeedback_Y_a;



    /* SystemInitialize for Outport: '<S620>/EPBPCMManualStatusFeedback' */

    L4_MABX_B.SFunction1_o2_fk = L4_MABX_P.EPBPCMManualStatusFeedback_Y0_k;



    /* SystemInitialize for Outport: '<S620>/RX status' */

    L4_MABX_B.SFunction1_o3_p = L4_MABX_P.RXstatus_Y0_ll;



    /* SystemInitialize for Outport: '<S620>/RX time' */

    L4_MABX_B.SFunction1_o4_au = L4_MABX_P.RXtime_Y0_in;



    /* SystemInitialize for Outport: '<S620>/RX delta time' */

    L4_MABX_B.SFunction1_o5_ne = L4_MABX_P.RXdeltatime_Y0_jk;



    /* End of SystemInitialize for SubSystem: '<S616>/CAN_TYPE1_RX_M2_C1' */



    /* SystemInitialize for Enabled SubSystem: '<S627>/PX2_LaneEdgeLeft' */

    /* SystemInitialize for Outport: '<S628>/PX2_LaneEdgeLeftAngle' */

    L4_MABX_B.SFunction1_o1_mj = L4_MABX_P.PX2_LaneEdgeLeftAngle_Y0;



    /* SystemInitialize for Outport: '<S628>/PX2_LaneEdgeLeftNumPoints' */

    L4_MABX_B.SFunction1_o2_ls = L4_MABX_P.PX2_LaneEdgeLeftNumPoints_Y0;



    /* SystemInitialize for Outport: '<S628>/PX2_LaneEdgeLeftPosition' */

    L4_MABX_B.SFunction1_o3_c1 = L4_MABX_P.PX2_LaneEdgeLeftPosition_Y0;



    /* SystemInitialize for Outport: '<S628>/RX status' */

    L4_MABX_B.SFunction1_o4_fz = L4_MABX_P.RXstatus_Y0_nm;



    /* SystemInitialize for Outport: '<S628>/RX time' */

    L4_MABX_B.SFunction1_o5_e = L4_MABX_P.RXtime_Y0_g1;



    /* SystemInitialize for Outport: '<S628>/RX delta time' */

    L4_MABX_B.SFunction1_o6_l0 = L4_MABX_P.RXdeltatime_Y0_go;



    /* End of SystemInitialize for SubSystem: '<S627>/PX2_LaneEdgeLeft' */



    /* SystemInitialize for Enabled SubSystem: '<S627>/PX2_LaneEdgeRight' */

    /* SystemInitialize for Outport: '<S629>/PX2_LaneEdgeRightAngle' */

    L4_MABX_B.SFunction1_o1_i2 = L4_MABX_P.PX2_LaneEdgeRightAngle_Y0;



    /* SystemInitialize for Outport: '<S629>/PX2_LaneEdgeRightNumPoints' */

    L4_MABX_B.SFunction1_o2_dg = L4_MABX_P.PX2_LaneEdgeRightNumPoints_Y0;



    /* SystemInitialize for Outport: '<S629>/PX2_LaneEdgeRightPosition' */

    L4_MABX_B.SFunction1_o3_ad = L4_MABX_P.PX2_LaneEdgeRightPosition_Y0;



    /* SystemInitialize for Outport: '<S629>/RX status' */

    L4_MABX_B.SFunction1_o4_dh = L4_MABX_P.RXstatus_Y0_ir;



    /* SystemInitialize for Outport: '<S629>/RX time' */

    L4_MABX_B.SFunction1_o5_fm = L4_MABX_P.RXtime_Y0_g10;



    /* SystemInitialize for Outport: '<S629>/RX delta time' */

    L4_MABX_B.SFunction1_o6_h = L4_MABX_P.RXdeltatime_Y0_o3;



    /* End of SystemInitialize for SubSystem: '<S627>/PX2_LaneEdgeRight' */



    /* SystemInitialize for Enabled SubSystem: '<S638>/PX2_MapLaneEgoLeft' */

    /* SystemInitialize for Outport: '<S639>/PX2_MapLaneNearPos' */

    L4_MABX_B.SFunction1_o1_ed = L4_MABX_P.PX2_MapLaneNearPos_Y0;



    /* SystemInitialize for Outport: '<S639>/PX2_MapLaneMidPos' */

    L4_MABX_B.SFunction1_o2_iv = L4_MABX_P.PX2_MapLaneMidPos_Y0;



    /* SystemInitialize for Outport: '<S639>/PX2_MapLaneFarPos' */

    L4_MABX_B.SFunction1_o3_df = L4_MABX_P.PX2_MapLaneFarPos_Y0;



    /* SystemInitialize for Outport: '<S639>/PX2_EgoLaneNearPosValid' */

    L4_MABX_B.SFunction1_o4_ak = L4_MABX_P.PX2_EgoLaneNearPosValid_Y0;



    /* SystemInitialize for Outport: '<S639>/PX2_EgoLaneMidPosValid' */

    L4_MABX_B.SFunction1_o5_f1 = L4_MABX_P.PX2_EgoLaneMidPosValid_Y0;



    /* SystemInitialize for Outport: '<S639>/PX2_EgoLaneFarPosValid' */

    L4_MABX_B.SFunction1_o6_i = L4_MABX_P.PX2_EgoLaneFarPosValid_Y0;



    /* SystemInitialize for Outport: '<S639>/RX status' */

    L4_MABX_B.SFunction1_o7_c5 = L4_MABX_P.RXstatus_Y0_a5;



    /* SystemInitialize for Outport: '<S639>/RX time' */

    L4_MABX_B.SFunction1_o8_e = L4_MABX_P.RXtime_Y0_bt;



    /* SystemInitialize for Outport: '<S639>/RX delta time' */

    L4_MABX_B.SFunction1_o9_g = L4_MABX_P.RXdeltatime_Y0_br;



    /* End of SystemInitialize for SubSystem: '<S638>/PX2_MapLaneEgoLeft' */



    /* SystemInitialize for Enabled SubSystem: '<S640>/PX2_MapLaneEgoRight' */

    /* SystemInitialize for Outport: '<S641>/PX2_MapLaneNearPos' */

    L4_MABX_B.SFunction1_o1_m5 = L4_MABX_P.PX2_MapLaneNearPos_Y0_k;



    /* SystemInitialize for Outport: '<S641>/PX2_MapLaneMidPos' */

    L4_MABX_B.SFunction1_o2_dv = L4_MABX_P.PX2_MapLaneMidPos_Y0_i;



    /* SystemInitialize for Outport: '<S641>/PX2_MapLaneFarPos' */

    L4_MABX_B.SFunction1_o3_em = L4_MABX_P.PX2_MapLaneFarPos_Y0_d;



    /* SystemInitialize for Outport: '<S641>/PX2_EgoLaneNearPosValid' */

    L4_MABX_B.SFunction1_o4_mn = L4_MABX_P.PX2_EgoLaneNearPosValid_Y0_o;



    /* SystemInitialize for Outport: '<S641>/PX2_EgoLaneMidPosValid' */

    L4_MABX_B.SFunction1_o5_gr = L4_MABX_P.PX2_EgoLaneMidPosValid_Y0_a;



    /* SystemInitialize for Outport: '<S641>/PX2_EgoLaneFarPosValid' */

    L4_MABX_B.SFunction1_o6_n = L4_MABX_P.PX2_EgoLaneFarPosValid_Y0_m;



    /* SystemInitialize for Outport: '<S641>/RX status' */

    L4_MABX_B.SFunction1_o7_fg = L4_MABX_P.RXstatus_Y0_i2t;



    /* SystemInitialize for Outport: '<S641>/RX time' */

    L4_MABX_B.SFunction1_o8_a = L4_MABX_P.RXtime_Y0_ew;



    /* SystemInitialize for Outport: '<S641>/RX delta time' */

    L4_MABX_B.SFunction1_o9_k = L4_MABX_P.RXdeltatime_Y0_ei;



    /* End of SystemInitialize for SubSystem: '<S640>/PX2_MapLaneEgoRight' */



    /* SystemInitialize for Enabled SubSystem: '<S642>/PX2_EgoLanePos' */

    /* SystemInitialize for Outport: '<S643>/PX2_EgoLaneNearPosErr' */

    L4_MABX_B.SFunction1_o1_kz = L4_MABX_P.PX2_EgoLaneNearPosErr_Y0;



    /* SystemInitialize for Outport: '<S643>/PX2_EgoLaneMidPosErr' */

    L4_MABX_B.SFunction1_o2_bb = L4_MABX_P.PX2_EgoLaneMidPosErr_Y0;



    /* SystemInitialize for Outport: '<S643>/PX2_EgoLaneFarPosErr' */

    L4_MABX_B.SFunction1_o3_n = L4_MABX_P.PX2_EgoLaneFarPosErr_Y0;



    /* SystemInitialize for Outport: '<S643>/PX2_EgoLaneNearPosValid' */

    L4_MABX_B.SFunction1_o4_gq = L4_MABX_P.PX2_EgoLaneNearPosValid_Y0_e;



    /* SystemInitialize for Outport: '<S643>/PX2_EgoLaneMidPosValid' */

    L4_MABX_B.SFunction1_o5_p = L4_MABX_P.PX2_EgoLaneMidPosValid_Y0_p;



    /* SystemInitialize for Outport: '<S643>/PX2_EgoLaneFarPosValid' */

    L4_MABX_B.SFunction1_o6_g = L4_MABX_P.PX2_EgoLaneFarPosValid_Y0_c;



    /* SystemInitialize for Outport: '<S643>/RX status' */

    L4_MABX_B.SFunction1_o7_l = L4_MABX_P.RXstatus_Y0_jn;



    /* SystemInitialize for Outport: '<S643>/RX time' */

    L4_MABX_B.SFunction1_o8_n = L4_MABX_P.RXtime_Y0_hp;



    /* SystemInitialize for Outport: '<S643>/RX delta time' */

    L4_MABX_B.SFunction1_o9_c = L4_MABX_P.RXdeltatime_Y0_au;



    /* End of SystemInitialize for SubSystem: '<S642>/PX2_EgoLanePos' */



    /* SystemInitialize for Enabled SubSystem: '<S652>/VEP1' */

    /* SystemInitialize for Outport: '<S653>/NetBatteryCurrent' */

    L4_MABX_B.SFunction1_o1_d = L4_MABX_P.NetBatteryCurrent_Y0;



    /* SystemInitialize for Outport: '<S653>/AltCurrent' */

    L4_MABX_B.SFunction1_o2_lz = L4_MABX_P.AltCurrent_Y0;



    /* SystemInitialize for Outport: '<S653>/ChargingSystemPotential' */

    L4_MABX_B.SFunction1_o3_j5 = L4_MABX_P.ChargingSystemPotential_Y0;



    /* SystemInitialize for Outport: '<S653>/BatteryPotential_PowerInput1' */

    L4_MABX_B.SFunction1_o4_pz = L4_MABX_P.BatteryPotential_PowerInput1_Y0;



    /* SystemInitialize for Outport: '<S653>/KeyswitchBatteryPotential' */

    L4_MABX_B.SFunction1_o5 = L4_MABX_P.KeyswitchBatteryPotential_Y0;



    /* SystemInitialize for Outport: '<S653>/RX status' */

    L4_MABX_B.SFunction1_o6 = L4_MABX_P.RXstatus_Y0_bs;



    /* SystemInitialize for Outport: '<S653>/RX time' */

    L4_MABX_B.SFunction1_o7 = L4_MABX_P.RXtime_Y0_o;



    /* SystemInitialize for Outport: '<S653>/RX delta time' */

    L4_MABX_B.SFunction1_o8 = L4_MABX_P.RXdeltatime_Y0_ky5;



    /* End of SystemInitialize for SubSystem: '<S652>/VEP1' */



    /* SystemInitialize for Enabled SubSystem: '<S475>/Decode_TPCM_CTS' */

    /* SystemInitialize for Outport: '<S694>/Out' */

    L4_MABX_B.SPN2556_ControlByte_k = (uint8_T)L4_MABX_P.Out_Y0_l;

    L4_MABX_B.SPN2561_NumberOfPacketsThatCanB = (uint8_T)L4_MABX_P.Out_Y0_l;

    L4_MABX_B.SPN2562_NextPacketNumberToBeSen = (uint8_T)L4_MABX_P.Out_Y0_l;

    L4_MABX_B.DataType_b1 = (uint32_T)L4_MABX_P.Out_Y0_l;



    /* End of SystemInitialize for SubSystem: '<S475>/Decode_TPCM_CTS' */



    /* SystemInitialize for Enabled SubSystem: '<S475>/Decode_TPCM_ConnectionAbort' */

    /* SystemInitialize for Outport: '<S695>/Out' */

    L4_MABX_B.SPN2556_ControlByte_g = (uint8_T)L4_MABX_P.Out_Y0_a;

    L4_MABX_B.SPN2570_ConnectionAbortReason = (uint8_T)L4_MABX_P.Out_Y0_a;

    L4_MABX_B.DataType_pd = (uint32_T)L4_MABX_P.Out_Y0_a;



    /* End of SystemInitialize for SubSystem: '<S475>/Decode_TPCM_ConnectionAbort' */



    /* SystemInitialize for Enabled SubSystem: '<S475>/Decode_TPCM_EndOfMessageAck' */

    /* SystemInitialize for Outport: '<S696>/Out' */

    L4_MABX_B.SPN2556_ControlByte_i = (uint8_T)L4_MABX_P.Out_Y0_d;

    L4_MABX_B.DataType_ilc = (uint16_T)L4_MABX_P.Out_Y0_d;

    L4_MABX_B.SPN2565_TotalNumberOfPackets = (uint8_T)L4_MABX_P.Out_Y0_d;

    L4_MABX_B.DataType_m2 = (uint32_T)L4_MABX_P.Out_Y0_d;



    /* End of SystemInitialize for SubSystem: '<S475>/Decode_TPCM_EndOfMessageAck' */



    /* SystemInitialize for Enabled SubSystem: '<S475>/Decode_TPCM_RTS' */

    /* SystemInitialize for Outport: '<S697>/Out' */

    L4_MABX_B.SPN2556_ControlByte = (uint8_T)L4_MABX_P.Out_Y0_k;

    L4_MABX_B.DataType_fn = (uint16_T)L4_MABX_P.Out_Y0_k;

    L4_MABX_B.SPN2558_TotalNumberOfPackets = (uint8_T)L4_MABX_P.Out_Y0_k;

    L4_MABX_B.SPN2559_MaximumNumberOfPackets = (uint8_T)L4_MABX_P.Out_Y0_k;

    L4_MABX_B.DataType_ke = (uint32_T)L4_MABX_P.Out_Y0_k;



    /* End of SystemInitialize for SubSystem: '<S475>/Decode_TPCM_RTS' */



    /* SystemInitialize for Enabled SubSystem: '<S588>/CAN_TYPE1_RX_M1_C1' */

    /* SystemInitialize for Outport: '<S592>/byte1' */

    L4_MABX_B.SFunction1_o1_f0 = L4_MABX_P.byte1_Y0_g;



    /* SystemInitialize for Outport: '<S592>/byte2' */

    L4_MABX_B.SFunction1_o2_pl = L4_MABX_P.byte2_Y0_n;



    /* SystemInitialize for Outport: '<S592>/byte3' */

    L4_MABX_B.SFunction1_o3_pe = L4_MABX_P.byte3_Y0_m;



    /* SystemInitialize for Outport: '<S592>/byte4' */

    L4_MABX_B.SFunction1_o4_h2 = L4_MABX_P.byte4_Y0_l;



    /* SystemInitialize for Outport: '<S592>/byte5' */

    L4_MABX_B.SFunction1_o5_m0 = L4_MABX_P.byte5_Y0_c;



    /* SystemInitialize for Outport: '<S592>/byte6' */

    L4_MABX_B.SFunction1_o6_b1 = L4_MABX_P.byte6_Y0_m;



    /* SystemInitialize for Outport: '<S592>/byte7' */

    L4_MABX_B.SFunction1_o7_al = L4_MABX_P.byte7_Y0_i;



    /* SystemInitialize for Outport: '<S592>/byte8' */

    L4_MABX_B.SFunction1_o8_ar = L4_MABX_P.byte8_Y0_m;



    /* SystemInitialize for Outport: '<S592>/RX status' */

    L4_MABX_B.SFunction1_o9_i4 = L4_MABX_P.RXstatus_Y0_fg;



    /* SystemInitialize for Outport: '<S592>/RX time' */

    L4_MABX_B.SFunction1_o10_hc = L4_MABX_P.RXtime_Y0_p;



    /* SystemInitialize for Outport: '<S592>/RX delta time' */

    L4_MABX_B.SFunction1_o11_n = L4_MABX_P.RXdeltatime_Y0_pn;



    /* End of SystemInitialize for SubSystem: '<S588>/CAN_TYPE1_RX_M1_C1' */



    /* SystemInitialize for Enabled SubSystem: '<S589>/CAN_TYPE1_RX_M1_C2' */

    /* SystemInitialize for Outport: '<S593>/byte1' */

    L4_MABX_B.SFunction1_o1_np = L4_MABX_P.byte1_Y0_j;



    /* SystemInitialize for Outport: '<S593>/byte2' */

    L4_MABX_B.SFunction1_o2_bp = L4_MABX_P.byte2_Y0_m;



    /* SystemInitialize for Outport: '<S593>/byte3' */

    L4_MABX_B.SFunction1_o3_cq = L4_MABX_P.byte3_Y0_f;



    /* SystemInitialize for Outport: '<S593>/byte4' */

    L4_MABX_B.SFunction1_o4_ph = L4_MABX_P.byte4_Y0_e;



    /* SystemInitialize for Outport: '<S593>/byte5' */

    L4_MABX_B.SFunction1_o5_iy = L4_MABX_P.byte5_Y0_f;



    /* SystemInitialize for Outport: '<S593>/byte6' */

    L4_MABX_B.SFunction1_o6_g4 = L4_MABX_P.byte6_Y0_my;



    /* SystemInitialize for Outport: '<S593>/byte7' */

    L4_MABX_B.SFunction1_o7_ea = L4_MABX_P.byte7_Y0_l;



    /* SystemInitialize for Outport: '<S593>/byte8' */

    L4_MABX_B.SFunction1_o8_c = L4_MABX_P.byte8_Y0_d;



    /* SystemInitialize for Outport: '<S593>/RX status' */

    L4_MABX_B.SFunction1_o9_jm = L4_MABX_P.RXstatus_Y0_go;



    /* SystemInitialize for Outport: '<S593>/RX time' */

    L4_MABX_B.SFunction1_o10_o = L4_MABX_P.RXtime_Y0_e;



    /* SystemInitialize for Outport: '<S593>/RX delta time' */

    L4_MABX_B.SFunction1_o11_fl = L4_MABX_P.RXdeltatime_Y0_am;



    /* End of SystemInitialize for SubSystem: '<S589>/CAN_TYPE1_RX_M1_C2' */



    /* SystemInitialize for Enabled SubSystem: '<S590>/CAN_TYPE1_RX_M3_C2' */

    /* SystemInitialize for Outport: '<S594>/byte1' */

    L4_MABX_B.SFunction1_o1_ae = L4_MABX_P.byte1_Y0_l;



    /* SystemInitialize for Outport: '<S594>/byte2' */

    L4_MABX_B.SFunction1_o2_nt = L4_MABX_P.byte2_Y0_o;



    /* SystemInitialize for Outport: '<S594>/byte3' */

    L4_MABX_B.SFunction1_o3_ng = L4_MABX_P.byte3_Y0_b;



    /* SystemInitialize for Outport: '<S594>/byte4' */

    L4_MABX_B.SFunction1_o4_okw = L4_MABX_P.byte4_Y0_f;



    /* SystemInitialize for Outport: '<S594>/byte5' */

    L4_MABX_B.SFunction1_o5_l = L4_MABX_P.byte5_Y0_g;



    /* SystemInitialize for Outport: '<S594>/byte6' */

    L4_MABX_B.SFunction1_o6_nq = L4_MABX_P.byte6_Y0_e;



    /* SystemInitialize for Outport: '<S594>/byte7' */

    L4_MABX_B.SFunction1_o7_lb = L4_MABX_P.byte7_Y0_i0;



    /* SystemInitialize for Outport: '<S594>/byte8' */

    L4_MABX_B.SFunction1_o8_bi = L4_MABX_P.byte8_Y0_h;



    /* SystemInitialize for Outport: '<S594>/RX status' */

    L4_MABX_B.SFunction1_o9_kq = L4_MABX_P.RXstatus_Y0_pk;



    /* SystemInitialize for Outport: '<S594>/RX time' */

    L4_MABX_B.SFunction1_o10_f = L4_MABX_P.RXtime_Y0_cl;



    /* SystemInitialize for Outport: '<S594>/RX delta time' */

    L4_MABX_B.SFunction1_o11_o = L4_MABX_P.RXdeltatime_Y0_oj;



    /* End of SystemInitialize for SubSystem: '<S590>/CAN_TYPE1_RX_M3_C2' */



    /* SystemInitialize for Enabled SubSystem: '<S601>/CAN_TYPE1_RX_M1_C1' */

    /* SystemInitialize for Outport: '<S605>/byte1' */

    L4_MABX_B.SFunction1_o1_nw = L4_MABX_P.byte1_Y0_k;



    /* SystemInitialize for Outport: '<S605>/byte2' */

    L4_MABX_B.SFunction1_o2_bx = L4_MABX_P.byte2_Y0_b;



    /* SystemInitialize for Outport: '<S605>/byte3' */

    L4_MABX_B.SFunction1_o3_hu = L4_MABX_P.byte3_Y0_c;



    /* SystemInitialize for Outport: '<S605>/byte4' */

    L4_MABX_B.SFunction1_o4_i2 = L4_MABX_P.byte4_Y0_kh;



    /* SystemInitialize for Outport: '<S605>/byte5' */

    L4_MABX_B.SFunction1_o5_mc = L4_MABX_P.byte5_Y0_fc;



    /* SystemInitialize for Outport: '<S605>/byte6' */

    L4_MABX_B.SFunction1_o6_bm = L4_MABX_P.byte6_Y0_f;



    /* SystemInitialize for Outport: '<S605>/byte7' */

    L4_MABX_B.SFunction1_o7_p0 = L4_MABX_P.byte7_Y0_l0;



    /* SystemInitialize for Outport: '<S605>/byte8' */

    L4_MABX_B.SFunction1_o8_j = L4_MABX_P.byte8_Y0_g;



    /* SystemInitialize for Outport: '<S605>/RX status' */

    L4_MABX_B.SFunction1_o9_e = L4_MABX_P.RXstatus_Y0_pz;



    /* SystemInitialize for Outport: '<S605>/RX time' */

    L4_MABX_B.SFunction1_o10_a = L4_MABX_P.RXtime_Y0_lz;



    /* SystemInitialize for Outport: '<S605>/RX delta time' */

    L4_MABX_B.SFunction1_o11_f = L4_MABX_P.RXdeltatime_Y0_hu;



    /* End of SystemInitialize for SubSystem: '<S601>/CAN_TYPE1_RX_M1_C1' */



    /* SystemInitialize for Enabled SubSystem: '<S602>/CAN_TYPE1_RX_M1_C2' */

    /* SystemInitialize for Outport: '<S606>/byte1' */

    L4_MABX_B.SFunction1_o1_dc = L4_MABX_P.byte1_Y0_o;



    /* SystemInitialize for Outport: '<S606>/byte2' */

    L4_MABX_B.SFunction1_o2_bu = L4_MABX_P.byte2_Y0_p;



    /* SystemInitialize for Outport: '<S606>/byte3' */

    L4_MABX_B.SFunction1_o3_mi = L4_MABX_P.byte3_Y0_i;



    /* SystemInitialize for Outport: '<S606>/byte4' */

    L4_MABX_B.SFunction1_o4_hm = L4_MABX_P.byte4_Y0_m;



    /* SystemInitialize for Outport: '<S606>/byte5' */

    L4_MABX_B.SFunction1_o5_bl = L4_MABX_P.byte5_Y0_cn;



    /* SystemInitialize for Outport: '<S606>/byte6' */

    L4_MABX_B.SFunction1_o6_e = L4_MABX_P.byte6_Y0_j;



    /* SystemInitialize for Outport: '<S606>/byte7' */

    L4_MABX_B.SFunction1_o7_cl = L4_MABX_P.byte7_Y0_j;



    /* SystemInitialize for Outport: '<S606>/byte8' */

    L4_MABX_B.SFunction1_o8_d = L4_MABX_P.byte8_Y0_ho;



    /* SystemInitialize for Outport: '<S606>/RX status' */

    L4_MABX_B.SFunction1_o9_o = L4_MABX_P.RXstatus_Y0_ku;



    /* SystemInitialize for Outport: '<S606>/RX time' */

    L4_MABX_B.SFunction1_o10_p = L4_MABX_P.RXtime_Y0_dj;



    /* SystemInitialize for Outport: '<S606>/RX delta time' */

    L4_MABX_B.SFunction1_o11_g = L4_MABX_P.RXdeltatime_Y0_jj;



    /* End of SystemInitialize for SubSystem: '<S602>/CAN_TYPE1_RX_M1_C2' */



    /* SystemInitialize for Enabled SubSystem: '<S603>/CAN_TYPE1_RX_M3_C2' */

    /* SystemInitialize for Outport: '<S607>/byte1' */

    L4_MABX_B.SFunction1_o1_oz = L4_MABX_P.byte1_Y0_f;



    /* SystemInitialize for Outport: '<S607>/byte2' */

    L4_MABX_B.SFunction1_o2_hr = L4_MABX_P.byte2_Y0_f;



    /* SystemInitialize for Outport: '<S607>/byte3' */

    L4_MABX_B.SFunction1_o3_cc = L4_MABX_P.byte3_Y0_l;



    /* SystemInitialize for Outport: '<S607>/byte4' */

    L4_MABX_B.SFunction1_o4_ok = L4_MABX_P.byte4_Y0_a;



    /* SystemInitialize for Outport: '<S607>/byte5' */

    L4_MABX_B.SFunction1_o5_m = L4_MABX_P.byte5_Y0_a;



    /* SystemInitialize for Outport: '<S607>/byte6' */

    L4_MABX_B.SFunction1_o6_p = L4_MABX_P.byte6_Y0_o;



    /* SystemInitialize for Outport: '<S607>/byte7' */

    L4_MABX_B.SFunction1_o7_pe = L4_MABX_P.byte7_Y0_p;



    /* SystemInitialize for Outport: '<S607>/byte8' */

    L4_MABX_B.SFunction1_o8_o = L4_MABX_P.byte8_Y0_n2;



    /* SystemInitialize for Outport: '<S607>/RX status' */

    L4_MABX_B.SFunction1_o9_h = L4_MABX_P.RXstatus_Y0_a;



    /* SystemInitialize for Outport: '<S607>/RX time' */

    L4_MABX_B.SFunction1_o10_c = L4_MABX_P.RXtime_Y0_k;



    /* SystemInitialize for Outport: '<S607>/RX delta time' */

    L4_MABX_B.SFunction1_o11_a = L4_MABX_P.RXdeltatime_Y0_o0;



    /* End of SystemInitialize for SubSystem: '<S603>/CAN_TYPE1_RX_M3_C2' */



    /* SystemInitialize for Enabled SubSystem: '<S1>/BUS_OFF_RECOVERY_1' */

    /* InitializeConditions for UnitDelay: '<S30>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_f1 = L4_MABX_P.Unit_Delay_InitialCondition_e3;



    /* InitializeConditions for UnitDelay: '<S31>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_j1 = L4_MABX_P.UnitDelay_InitialCondition_nq;



    /* End of SystemInitialize for SubSystem: '<S1>/BUS_OFF_RECOVERY_1' */



    /* SystemInitialize for Enabled SubSystem: '<S1>/BUS_OFF_RECOVERY_5' */

    /* InitializeConditions for UnitDelay: '<S54>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_i5 = L4_MABX_P.Unit_Delay_InitialCondition_ot;



    /* InitializeConditions for UnitDelay: '<S55>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_p = L4_MABX_P.UnitDelay_InitialCondition_p;



    /* End of SystemInitialize for SubSystem: '<S1>/BUS_OFF_RECOVERY_5' */



    /* SystemInitialize for Enabled SubSystem: '<S1>/BUS_OFF_RECOVERY_6' */

    /* InitializeConditions for UnitDelay: '<S60>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_l5 = L4_MABX_P.Unit_Delay_InitialCondition_le;



    /* InitializeConditions for UnitDelay: '<S61>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_dr = L4_MABX_P.UnitDelay_InitialCondition_iv;



    /* End of SystemInitialize for SubSystem: '<S1>/BUS_OFF_RECOVERY_6' */



    /* SystemInitialize for Enabled SubSystem: '<S1>/BUS_OFF_RECOVERY_3' */

    /* InitializeConditions for UnitDelay: '<S42>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_h41 = L4_MABX_P.Unit_Delay_InitialCondition_m;



    /* InitializeConditions for UnitDelay: '<S43>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_dr4 = L4_MABX_P.UnitDelay_InitialCondition_hk;



    /* End of SystemInitialize for SubSystem: '<S1>/BUS_OFF_RECOVERY_3' */



    /* SystemInitialize for Enabled SubSystem: '<S1>/BUS_OFF_RECOVERY_4' */

    /* InitializeConditions for UnitDelay: '<S48>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_mq = L4_MABX_P.Unit_Delay_InitialCondition_bo;



    /* InitializeConditions for UnitDelay: '<S49>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_h = L4_MABX_P.UnitDelay_InitialCondition_l;



    /* End of SystemInitialize for SubSystem: '<S1>/BUS_OFF_RECOVERY_4' */



    /* SystemInitialize for Enabled SubSystem: '<S1>/BUS_OFF_RECOVERY_2' */

    /* InitializeConditions for UnitDelay: '<S36>/Unit_Delay' */

    L4_MABX_DW.Unit_Delay_DSTATE_je = L4_MABX_P.Unit_Delay_InitialCondition_in;



    /* InitializeConditions for UnitDelay: '<S37>/Unit Delay' */

    L4_MABX_DW.UnitDelay_DSTATE_b = L4_MABX_P.UnitDelay_InitialCondition_m;



    /* End of SystemInitialize for SubSystem: '<S1>/BUS_OFF_RECOVERY_2' */

  }

}



/* Model terminate function */

void L4_MABX_terminate(void)

{

  /* Terminate for Atomic SubSystem: '<S855>/CAN_TX_1000ms' */



  /* Terminate for Enabled SubSystem: '<S875>/AIR1' */



  /* Terminate for S-Function (rti_commonblock): '<S876>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "AIR1" Id:419343921 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[1][3] = can_tp1_msg_sleep

            (can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEAE31])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S875>/AIR1' */



  /* Terminate for Enabled SubSystem: '<S883>/AMB' */



  /* Terminate for S-Function (rti_commonblock): '<S884>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "AMB" Id:419362048 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[1][4] = can_tp1_msg_sleep

            (can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18FEF500])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S883>/AMB' */



  /* End of Terminate for SubSystem: '<S855>/CAN_TX_1000ms' */



  /* Terminate for S-Function (dsa_tcpip_setup_sfcn): '<S405>/dsa_tcpip_setup' */

  /* Level2 S-Function Block: '<S405>/dsa_tcpip_setup' (dsa_tcpip_setup_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[3];

    sfcnTerminate(rts);

  }



  /* Terminate for S-Function (dsa_tcpip_udp_sfcn): '<S406>/TCPIP_Com' */

  /* Level2 S-Function Block: '<S406>/TCPIP_Com' (dsa_tcpip_udp_sfcn) */

  {

    SimStruct *rts = L4_MABX_M->childSfunctions[4];

    sfcnTerminate(rts);

  }



  /* Terminate for Atomic SubSystem: '<S855>/CAN_TX_100ms' */



  /* Terminate for Enabled SubSystem: '<S914>/PropB_XPR_FC' */



  /* Terminate for S-Function (rti_commonblock): '<S916>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "PropB_XPR_FC" Id:419366140 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[0][4] = can_tp1_msg_sleep

            (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18FF04FC])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S914>/PropB_XPR_FC' */



  /* Terminate for Enabled SubSystem: '<S915>/PropB_XPR_FC' */



  /* Terminate for S-Function (rti_commonblock): '<S917>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "PropB_XPR_FC" Id:419366140 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[1][4] = can_tp1_msg_sleep

            (can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FF04FC])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S915>/PropB_XPR_FC' */



  /* Terminate for Enabled SubSystem: '<S944>/Std_PosRapidUpdate_01' */



  /* Terminate for S-Function (rti_commonblock): '<S945>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "Std_PosRapidUpdate_01" Id:3 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[2][0] = can_tp1_msg_sleep

            (can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0X3])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S944>/Std_PosRapidUpdate_01' */



  /* Terminate for Enabled SubSystem: '<S894>/CCVS1_00' */



  /* Terminate for S-Function (rti_commonblock): '<S896>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "CCVS1_00" Id:419361024 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[0][3] = can_tp1_msg_sleep

            (can_type1_msg_M1[CANTP1_M1_C2_TX_XTD_0X18FEF100])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S894>/CCVS1_00' */



  /* Terminate for Enabled SubSystem: '<S895>/CCVS1_00' */



  /* Terminate for S-Function (rti_commonblock): '<S897>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "CCVS1_00" Id:218034432 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[2][3] = can_tp1_msg_sleep

            (can_type1_msg_M3[CANTP1_M3_C2_TX_XTD_0XCFEF100])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S895>/CCVS1_00' */



  /* Terminate for Enabled SubSystem: '<S898>/PropB_REAX_5_E4' */



  /* Terminate for S-Function (rti_commonblock): '<S900>/S-Function1' incorporates:

   *  Constant: '<S898>/Constant'

   *  Constant: '<S898>/Constant1'

   */



  /* dSPACE RTICAN TX Message Block: "PropB_REAX_5_E4" Id:419429092 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[0][5] = can_tp1_msg_sleep

            (can_type1_msg_M1[CANTP1_M1_C2_TX_XTD_0X18FFFAE4])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S898>/PropB_REAX_5_E4' */



  /* Terminate for Enabled SubSystem: '<S899>/PropB_REAX_5_E4' */



  /* Terminate for S-Function (rti_commonblock): '<S901>/S-Function1' incorporates:

   *  Constant: '<S899>/Constant'

   *  Constant: '<S899>/Constant1'

   */



  /* dSPACE RTICAN TX Message Block: "PropB_REAX_5_E4" Id:419429092 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[2][4] = can_tp1_msg_sleep

            (can_type1_msg_M3[CANTP1_M3_C2_TX_XTD_0X18FFFAE4])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S899>/PropB_REAX_5_E4' */



  /* Terminate for Enabled SubSystem: '<S918>/Std_COGSOGRapidUpdate_01' */



  /* Terminate for S-Function (rti_commonblock): '<S919>/S-Function1' incorporates:

   *  Constant: '<S918>/Constant'

   *  Constant: '<S918>/Constant1'

   */



  /* dSPACE RTICAN TX Message Block: "Std_COGSOGRapidUpdate_01" Id:7 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[2][0] = can_tp1_msg_sleep

            (can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0X7])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S918>/Std_COGSOGRapidUpdate_01' */



  /* Terminate for Enabled SubSystem: '<S920>/EBC1_TX' */



  /* Terminate for S-Function (rti_commonblock): '<S921>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "EBC1_TX" Id:418382219 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[0][2] = can_tp1_msg_sleep

            (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18F0018B])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S920>/EBC1_TX' */



  /* End of Terminate for SubSystem: '<S855>/CAN_TX_100ms' */



  /* Terminate for Atomic SubSystem: '<S855>/CAN_TX_10ms' */



  /* Terminate for Enabled SubSystem: '<S957>/ACCS' */



  /* Terminate for S-Function (rti_commonblock): '<S958>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "ACCS" Id:418393572 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[1][3] = can_tp1_msg_sleep

            (can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0X18F02DE4])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S957>/ACCS' */



  /* Terminate for Enabled SubSystem: '<S965>/EEC1_00' */



  /* Terminate for S-Function (rti_commonblock): '<S967>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "EEC1_00" Id:217056256 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[1][1] = can_tp1_msg_sleep

            (can_type1_msg_M2[CANTP1_M2_C2_TX_XTD_0XCF00400])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S965>/EEC1_00' */



  /* Terminate for Enabled SubSystem: '<S966>/EEC1_00' */



  /* Terminate for S-Function (rti_commonblock): '<S968>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "EEC1_00" Id:217056256 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[2][3] = can_tp1_msg_sleep

            (can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0XCF00400])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S966>/EEC1_00' */



  /* Terminate for Enabled SubSystem: '<S969>/PropB_REAX_1_E4' */



  /* Terminate for S-Function (rti_commonblock): '<S971>/S-Function1' incorporates:

   *  Constant: '<S969>/Constant'

   *  Constant: '<S969>/Constant1'

   */



  /* dSPACE RTICAN TX Message Block: "PropB_REAX_1_E4" Id:419426276 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[0][4] = can_tp1_msg_sleep

            (can_type1_msg_M1[CANTP1_M1_C2_TX_XTD_0X18FFEFE4])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S969>/PropB_REAX_1_E4' */



  /* Terminate for Enabled SubSystem: '<S970>/PropB_REAX_1_E4' */



  /* Terminate for S-Function (rti_commonblock): '<S972>/S-Function1' incorporates:

   *  Constant: '<S970>/Constant'

   *  Constant: '<S970>/Constant1'

   */



  /* dSPACE RTICAN TX Message Block: "PropB_REAX_1_E4" Id:419426276 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[2][4] = can_tp1_msg_sleep

            (can_type1_msg_M3[CANTP1_M3_C2_TX_XTD_0X18FFEFE4])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S970>/PropB_REAX_1_E4' */



  /* Terminate for Enabled SubSystem: '<S979>/VDC2_0B' */



  /* Terminate for S-Function (rti_commonblock): '<S980>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "VDC2_0B" Id:418384139 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[2][4] = can_tp1_msg_sleep

            (can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18F0090B])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S979>/VDC2_0B' */



  /* End of Terminate for SubSystem: '<S855>/CAN_TX_10ms' */



  /* Terminate for Atomic SubSystem: '<S855>/CAN_TX_20ms' */



  /* Terminate for Enabled SubSystem: '<S1024>/PropB_XBR_B3' */



  /* Terminate for S-Function (rti_commonblock): '<S1025>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "PropB_XBR_B3" Id:218038707 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[1][2] = can_tp1_msg_sleep

            (can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF01B3])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S1024>/PropB_XBR_B3' */



  /* Terminate for Enabled SubSystem: '<S1026>/PropB_Bendix_2C2_XPR' */



  /* Terminate for S-Function (rti_commonblock): '<S1027>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "PropB_Bendix_2C2_XPR" Id:218060389 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[1][2] = can_tp1_msg_sleep

            (can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0XCFF5665])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S1026>/PropB_Bendix_2C2_XPR' */



  /* Terminate for Enabled SubSystem: '<S1034>/Std_OdometryData' */



  /* Terminate for S-Function (rti_commonblock): '<S1035>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "Std_OdometryData" Id:10 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[2][0] = can_tp1_msg_sleep

            (can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0XA])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S1034>/Std_OdometryData' */



  /* End of Terminate for SubSystem: '<S855>/CAN_TX_20ms' */



  /* Terminate for Atomic SubSystem: '<S855>/CAN_TX_5000ms' */



  /* Terminate for Enabled SubSystem: '<S1049>/RQST_13_E4' */



  /* Terminate for S-Function (rti_commonblock): '<S1051>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "RQST_13_E4" Id:417993700 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[2][3] = can_tp1_msg_sleep

            (can_type1_msg_M3[CANTP1_M3_C1_TX_XTD_0X18EA13E4])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S1049>/RQST_13_E4' */



  /* End of Terminate for SubSystem: '<S855>/CAN_TX_5000ms' */



  /* Terminate for Atomic SubSystem: '<S855>/CAN_TX_50ms' */



  /* Terminate for Enabled SubSystem: '<S1060>/CCVS1_E3' */



  /* Terminate for S-Function (rti_commonblock): '<S1062>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "CCVS1_E3" Id:419361251 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[1][3] = can_tp1_msg_sleep

            (can_type1_msg_M2[CANTP1_M2_C1_TX_XTD_0X18FEF1E3])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S1060>/CCVS1_E3' */



  /* Terminate for Enabled SubSystem: '<S1061>/TC1_03_05' */



  /* Terminate for S-Function (rti_commonblock): '<S1063>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "TC1_03_05" Id:201392901 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[0][0] = can_tp1_msg_sleep

            (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0XC010305])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S1061>/TC1_03_05' */



  /* End of Terminate for SubSystem: '<S855>/CAN_TX_50ms' */



  /* Terminate for Enabled SubSystem: '<S1073>/Std_SystemTime_01' */



  /* Terminate for S-Function (rti_commonblock): '<S1075>/S-Function1' incorporates:

   *  Constant: '<S1073>/Constant'

   *  Constant: '<S1073>/Constant1'

   */



  /* dSPACE RTICAN TX Message Block: "Std_SystemTime_01" Id:5 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[2][0] = can_tp1_msg_sleep

            (can_type1_msg_M3[CANTP1_M3_C2_TX_STD_0X5])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S1073>/Std_SystemTime_01' */



  /* Terminate for Triggered SubSystem: '<S1068>/CAN_TYPE1_TX_M1_C1' */



  /* Terminate for S-Function (rti_commonblock): '<S1070>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "TX Message" Id:418184965 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[0][1] = can_tp1_msg_sleep

            (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18ECFF05])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S1068>/CAN_TYPE1_TX_M1_C1' */



  /* Terminate for Triggered SubSystem: '<S1069>/CAN_TYPE1_TX_M1_C1' */



  /* Terminate for S-Function (rti_commonblock): '<S1071>/S-Function1' */



  /* dSPACE RTICAN TX Message Block: "TX Message" Id:418119429 */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[0][1] = can_tp1_msg_sleep

            (can_type1_msg_M1[CANTP1_M1_C1_TX_XTD_0X18EBFF05])) ==

           DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* End of Terminate for SubSystem: '<S1069>/CAN_TYPE1_TX_M1_C1' */



  /* Terminate for S-Function (rti_commonblock): '<S1076>/S-Function1' */



  /* disable digital output channel 1 on port 1 *

   * (set to high-impedance), when the simulation terminates       */

  dio_tp4_digout_init(DIO_TP4_1_MODULE_ADDR, 1, DIO_TP4_MASK_CH1,

                      DIO_TP4_LS_DISABLE, DIO_TP4_HS_DISABLE);



  /* Terminate for S-Function (rti_commonblock): '<S1077>/S-Function1' */



  /* disable digital output channel 2 on port 1 *

   * (set to high-impedance), when the simulation terminates       */

  dio_tp4_digout_init(DIO_TP4_1_MODULE_ADDR, 1, DIO_TP4_MASK_CH2,

                      DIO_TP4_LS_DISABLE, DIO_TP4_HS_DISABLE);



  /* Terminate for S-Function (rti_commonblock): '<S1078>/S-Function1' */



  /* disable digital output channel 6 on port 2 *

   * (set to high-impedance), when the simulation terminates       */

  dio_tp4_digout_init(DIO_TP4_1_MODULE_ADDR, 2, DIO_TP4_MASK_CH6,

                      DIO_TP4_LS_DISABLE, DIO_TP4_HS_DISABLE);



  /* Terminate for S-Function (rti_commonblock): '<S1079>/S-Function1' */



  /* disable digital output channel 1 on port 2 *

   * (set to high-impedance), when the simulation terminates */

  dio_tp4_pwm_init(DIO_TP4_1_MODULE_ADDR, 2, DIO_TP4_MASK_CH1,

                   DIO_TP4_LS_DISABLE, DIO_TP4_HS_DISABLE, DIO_TP4_TIMING_RANGE2,

                   DIO_TP4_PWM);



  /* Terminate for S-Function (rti_commonblock): '<S1080>/S-Function1' */



  /* disable digital output channel 2 on port 2 *

   * (set to high-impedance), when the simulation terminates */

  dio_tp4_pwm_init(DIO_TP4_1_MODULE_ADDR, 2, DIO_TP4_MASK_CH2,

                   DIO_TP4_LS_DISABLE, DIO_TP4_HS_DISABLE, DIO_TP4_TIMING_RANGE2,

                   DIO_TP4_PWM);



  /* Terminate for S-Function (rti_commonblock): '<S414>/S-Function1' incorporates:

   *  SubSystem: '<S405>/Background_Task'

   */

  L4_MAB_Background_Task_Term();



  /* End of Terminate for S-Function (rti_commonblock): '<S414>/S-Function1' */



  /* Terminate for S-Function (rti_commonblock): '<S420>/S-Function1' incorporates:

   *  SubSystem: '<S405>/Interrupt_Task'

   */

  L4_MABX_Interrupt_Task_Term();



  /* End of Terminate for S-Function (rti_commonblock): '<S420>/S-Function1' */



  /* Terminate for S-Function (rti_commonblock): '<S466>/S-Function1' */



  /* dSPACE RTICAN STD Srvc-Message Block */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[0][0] = can_tp1_msg_sleep

            (CANTP1_RX_SPMSG_M1_C1_STD)) == DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* dSPACE RTICAN XTD Srvc-Message Block */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[0][1] = can_tp1_msg_sleep

            (CANTP1_RX_SPMSG_M1_C1_XTD)) == DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* Terminate for S-Function (rti_commonblock): '<S467>/S-Function1' */



  /* dSPACE RTICAN STD Srvc-Message Block */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[0][0] = can_tp1_msg_sleep

            (CANTP1_RX_SPMSG_M1_C2_STD)) == DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* dSPACE RTICAN XTD Srvc-Message Block */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[0][1] = can_tp1_msg_sleep

            (CANTP1_RX_SPMSG_M1_C2_XTD)) == DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* Terminate for S-Function (rti_commonblock): '<S468>/S-Function1' */



  /* dSPACE RTICAN STD Srvc-Message Block */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[1][0] = can_tp1_msg_sleep

            (CANTP1_RX_SPMSG_M2_C1_STD)) == DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* dSPACE RTICAN XTD Srvc-Message Block */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[1][1] = can_tp1_msg_sleep

            (CANTP1_RX_SPMSG_M2_C1_XTD)) == DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* Terminate for S-Function (rti_commonblock): '<S469>/S-Function1' */



  /* dSPACE RTICAN STD Srvc-Message Block */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[1][0] = can_tp1_msg_sleep

            (CANTP1_RX_SPMSG_M2_C2_STD)) == DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* dSPACE RTICAN XTD Srvc-Message Block */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[1][1] = can_tp1_msg_sleep

            (CANTP1_RX_SPMSG_M2_C2_XTD)) == DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* Terminate for S-Function (rti_commonblock): '<S470>/S-Function1' */



  /* dSPACE RTICAN STD Srvc-Message Block */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[2][0] = can_tp1_msg_sleep

            (CANTP1_RX_SPMSG_M3_C1_STD)) == DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* dSPACE RTICAN XTD Srvc-Message Block */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[2][1] = can_tp1_msg_sleep

            (CANTP1_RX_SPMSG_M3_C1_XTD)) == DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* Terminate for S-Function (rti_commonblock): '<S471>/S-Function1' */



  /* dSPACE RTICAN STD Srvc-Message Block */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[2][0] = can_tp1_msg_sleep

            (CANTP1_RX_SPMSG_M3_C2_STD)) == DSMCOM_BUFFER_OVERFLOW) ;

  }



  /* dSPACE RTICAN XTD Srvc-Message Block */

  {

    /* ... Set the message into sleep mode */

    while ((rtican_type1_tq_error[2][1] = can_tp1_msg_sleep

            (CANTP1_RX_SPMSG_M3_C2_XTD)) == DSMCOM_BUFFER_OVERFLOW) ;

  }

}